using System;
using System.Runtime.InteropServices;

namespace Lime
{
	public static partial class GL
	{
		public static unsafe void CullFace(CullFaceMode mode)
		{
			glCullFace((uint)mode);
		}

		public static unsafe void FrontFace(FrontFaceDirection mode)
		{
			glFrontFace((uint)mode);
		}

		public static unsafe void Hint(HintTarget target, HintMode mode)
		{
			glHint((uint)target, (uint)mode);
		}

		public static unsafe void LineWidth(float width)
		{
			glLineWidth(width);
		}

		public static unsafe void PointSize(float size)
		{
			glPointSize(size);
		}

		public static unsafe void PolygonMode(MaterialFace face, PolygonMode mode)
		{
			glPolygonMode((uint)face, (uint)mode);
		}

		public static unsafe void Scissor(Int32 x, Int32 y, Int32 width, Int32 height)
		{
			glScissor(x, y, width, height);
		}

		public static unsafe void TexParameter(TextureTarget target, TextureParameterName pname, float param)
		{
			glTexParameterf((uint)target, (uint)pname, param);
		}

		public static unsafe void TexParameter(TextureTarget target, TextureParameterName pname, float[] parameters)
		{
			fixed (float* ptr0 = &parameters[0]) { glTexParameterfv((uint)target, (uint)pname, new IntPtr(ptr0)); } 
		}

		public static unsafe void TexParameter(TextureTarget target, TextureParameterName pname, Int32 param)
		{
			glTexParameteri((uint)target, (uint)pname, param);
		}

		public static unsafe void TexParameter(TextureTarget target, TextureParameterName pname, Int32[] parameters)
		{
			fixed (Int32* ptr1 = &parameters[0]) { glTexParameteriv((uint)target, (uint)pname, new IntPtr(ptr1)); } 
		}

		public static unsafe void TexImage1D(TextureTarget target, Int32 level, Int32 internalformat, Int32 width, Int32 border, PixelFormat format, PixelType type, IntPtr pixels)
		{
			glTexImage1D((uint)target, level, internalformat, width, border, (uint)format, (uint)type, pixels);
		}

		public static unsafe void TexImage2D(TextureTarget target, Int32 level, Int32 internalformat, Int32 width, Int32 height, Int32 border, PixelFormat format, PixelType type, IntPtr pixels)
		{
			glTexImage2D((uint)target, level, internalformat, width, height, border, (uint)format, (uint)type, pixels);
		}

		public static unsafe void DrawBuffer(DrawBufferMode mode)
		{
			glDrawBuffer((uint)mode);
		}

		public static unsafe void Clear(UInt32 mask)
		{
			glClear(mask);
		}

		public static unsafe void ClearColor(float red, float green, float blue, float alpha)
		{
			glClearColor(red, green, blue, alpha);
		}

		public static unsafe void ClearStencil(Int32 s)
		{
			glClearStencil(s);
		}

		public static unsafe void ClearDepth(double depth)
		{
			glClearDepth(depth);
		}

		public static unsafe void StencilMask(UInt32 mask)
		{
			glStencilMask(mask);
		}

		public static unsafe void ColorMask(bool red, bool green, bool blue, bool alpha)
		{
			glColorMask(red ? ((byte)1) : ((byte)0), green ? ((byte)1) : ((byte)0), blue ? ((byte)1) : ((byte)0), alpha ? ((byte)1) : ((byte)0));
		}

		public static unsafe void DepthMask(bool flag)
		{
			glDepthMask(flag ? ((byte)1) : ((byte)0));
		}

		public static unsafe void Disable(EnableCap cap)
		{
			glDisable((uint)cap);
		}

		public static unsafe void Enable(EnableCap cap)
		{
			glEnable((uint)cap);
		}

		public static unsafe void Finish()
		{
			glFinish();
		}

		public static unsafe void Flush()
		{
			glFlush();
		}

		public static unsafe void BlendFunc(BlendingFactorSrc sfactor, BlendingFactorDest dfactor)
		{
			glBlendFunc((uint)sfactor, (uint)dfactor);
		}

		public static unsafe void LogicOp(LogicOp opcode)
		{
			glLogicOp((uint)opcode);
		}

		public static unsafe void StencilFunc(StencilFunction func, Int32 reference, UInt32 mask)
		{
			glStencilFunc((uint)func, reference, mask);
		}

		public static unsafe void StencilOp(StencilOp fail, StencilOp zfail, StencilOp zpass)
		{
			glStencilOp((uint)fail, (uint)zfail, (uint)zpass);
		}

		public static unsafe void DepthFunc(DepthFunction func)
		{
			glDepthFunc((uint)func);
		}

		public static unsafe void PixelStoref(PixelStoreParameter pname, float param)
		{
			glPixelStoref((uint)pname, param);
		}

		public static unsafe void PixelStorei(PixelStoreParameter pname, Int32 param)
		{
			glPixelStorei((uint)pname, param);
		}

		public static unsafe void ReadBuffer(ReadBufferMode mode)
		{
			glReadBuffer((uint)mode);
		}

		public static unsafe void ReadPixels(Int32 x, Int32 y, Int32 width, Int32 height, PixelFormat format, PixelType type, [OutAttribute] IntPtr pixels)
		{
			glReadPixels(x, y, width, height, (uint)format, (uint)type, pixels);
		}

		public static unsafe void GetBooleanv(GetPName pname, [OutAttribute] bool[] parameters)
		{
			byte[] btr2 = new byte[1];
			fixed (byte* optr2 = btr2) { glGetBooleanv((uint)pname, optr2); }
			parameters = new bool[btr2.Length];
			for (int i2 = 0; i2< parameters.Length; i2++)
				parameters[i2] = (btr2[i2] == 1);
			 
		}

		public static unsafe void GetDoublev(GetPName pname, [OutAttribute] double[] parameters)
		{
			fixed (double* optr3 = parameters) { glGetDoublev((uint)pname, optr3); } 
		}

		public static unsafe ErrorCode GetError()
		{
			return (ErrorCode) glGetError();
		}

		public static unsafe void GetFloatv(GetPName pname, [OutAttribute] float[] parameters)
		{
			fixed (float* optr4 = parameters) { glGetFloatv((uint)pname, optr4); } 
		}

		public static unsafe void GetIntegerv(GetPName pname, [OutAttribute] Int32[] parameters)
		{
			fixed (Int32* optr5 = parameters) { glGetIntegerv((uint)pname, optr5); } 
		}

		public static unsafe IntPtr GetString(StringName name)
		{
			return glGetString((uint)name);
		}

		public static unsafe void GetTexImage(TextureTarget target, Int32 level, PixelFormat format, PixelType type, [OutAttribute] IntPtr pixels)
		{
			glGetTexImage((uint)target, level, (uint)format, (uint)type, pixels);
		}

		public static unsafe void GetTexParameterfv(TextureTarget target, GetTextureParameter pname, [OutAttribute] float[] parameters)
		{
			fixed (float* optr6 = parameters) { glGetTexParameterfv((uint)target, (uint)pname, optr6); } 
		}

		public static unsafe void GetTexParameteriv(TextureTarget target, GetTextureParameter pname, [OutAttribute] Int32[] parameters)
		{
			fixed (Int32* optr7 = parameters) { glGetTexParameteriv((uint)target, (uint)pname, optr7); } 
		}

		public static unsafe void GetTexLevelParameterfv(TextureTarget target, Int32 level, GetTextureParameter pname, [OutAttribute] float[] parameters)
		{
			fixed (float* optr8 = parameters) { glGetTexLevelParameterfv((uint)target, level, (uint)pname, optr8); } 
		}

		public static unsafe void GetTexLevelParameteriv(TextureTarget target, Int32 level, GetTextureParameter pname, [OutAttribute] Int32[] parameters)
		{
			fixed (Int32* optr9 = parameters) { glGetTexLevelParameteriv((uint)target, level, (uint)pname, optr9); } 
		}

		public static unsafe bool IsEnabled(EnableCap cap)
		{
			return (glIsEnabled((uint)cap) == 1);
		}

		public static unsafe void DepthRange(double near, double far)
		{
			glDepthRange(near, far);
		}

		public static unsafe void Viewport(Int32 x, Int32 y, Int32 width, Int32 height)
		{
			glViewport(x, y, width, height);
		}

		public static unsafe void NewList(UInt32 list, ListMode mode)
		{
			glNewList(list, (uint)mode);
		}

		public static unsafe void EndList()
		{
			glEndList();
		}

		public static unsafe void CallList(UInt32 list)
		{
			glCallList(list);
		}

		public static unsafe void CallLists(Int32 n, ListNameType type, IntPtr lists)
		{
			glCallLists(n, (uint)type, lists);
		}

		public static unsafe void DeleteLists(UInt32 list, Int32 range)
		{
			glDeleteLists(list, range);
		}

		public static unsafe UInt32 GenLists(Int32 range)
		{
			return glGenLists(range);
		}

		public static unsafe void ListBase(UInt32 base_)
		{
			glListBase(base_);
		}

		public static unsafe void Begin(BeginMode mode)
		{
			glBegin((uint)mode);
		}

		public static unsafe void Bitmap(Int32 width, Int32 height, float xorig, float yorig, float xmove, float ymove, byte[] bitmap)
		{
			fixed (byte* ptr10 = &bitmap[0]) { glBitmap(width, height, xorig, yorig, xmove, ymove, new IntPtr(ptr10)); } 
		}

		public static unsafe void Color3(SByte red, SByte green, SByte blue)
		{
			glColor3b(red, green, blue);
		}

		public static unsafe void Color3(SByte[] v)
		{
			fixed (SByte* ptr11 = &v[0]) { glColor3bv(new IntPtr(ptr11)); } 
		}

		public static unsafe void Color3(double red, double green, double blue)
		{
			glColor3d(red, green, blue);
		}

		public static unsafe void Color3(double[] v)
		{
			fixed (double* ptr12 = &v[0]) { glColor3dv(new IntPtr(ptr12)); } 
		}

		public static unsafe void Color3(float red, float green, float blue)
		{
			glColor3f(red, green, blue);
		}

		public static unsafe void Color3(float[] v)
		{
			fixed (float* ptr13 = &v[0]) { glColor3fv(new IntPtr(ptr13)); } 
		}

		public static unsafe void Color3(Int32 red, Int32 green, Int32 blue)
		{
			glColor3i(red, green, blue);
		}

		public static unsafe void Color3(Int32[] v)
		{
			fixed (Int32* ptr14 = &v[0]) { glColor3iv(new IntPtr(ptr14)); } 
		}

		public static unsafe void Color3(Int16 red, Int16 green, Int16 blue)
		{
			glColor3s(red, green, blue);
		}

		public static unsafe void Color3(Int16[] v)
		{
			fixed (Int16* ptr15 = &v[0]) { glColor3sv(new IntPtr(ptr15)); } 
		}

		public static unsafe void Color3(byte red, byte green, byte blue)
		{
			glColor3ub(red, green, blue);
		}

		public static unsafe void Color3(byte[] v)
		{
			fixed (byte* ptr16 = &v[0]) { glColor3ubv(new IntPtr(ptr16)); } 
		}

		public static unsafe void Color3(UInt32 red, UInt32 green, UInt32 blue)
		{
			glColor3ui(red, green, blue);
		}

		public static unsafe void Color3(UInt32[] v)
		{
			fixed (UInt32* ptr17 = &v[0]) { glColor3uiv(new IntPtr(ptr17)); } 
		}

		public static unsafe void Color3(UInt16 red, UInt16 green, UInt16 blue)
		{
			glColor3us(red, green, blue);
		}

		public static unsafe void Color3(UInt16[] v)
		{
			fixed (UInt16* ptr18 = &v[0]) { glColor3usv(new IntPtr(ptr18)); } 
		}

		public static unsafe void Color4(SByte red, SByte green, SByte blue, SByte alpha)
		{
			glColor4b(red, green, blue, alpha);
		}

		public static unsafe void Color4(SByte[] v)
		{
			fixed (SByte* ptr19 = &v[0]) { glColor4bv(new IntPtr(ptr19)); } 
		}

		public static unsafe void Color4(double red, double green, double blue, double alpha)
		{
			glColor4d(red, green, blue, alpha);
		}

		public static unsafe void Color4(double[] v)
		{
			fixed (double* ptr20 = &v[0]) { glColor4dv(new IntPtr(ptr20)); } 
		}

		public static unsafe void Color4(float red, float green, float blue, float alpha)
		{
			glColor4f(red, green, blue, alpha);
		}

		public static unsafe void Color4(float[] v)
		{
			fixed (float* ptr21 = &v[0]) { glColor4fv(new IntPtr(ptr21)); } 
		}

		public static unsafe void Color4(Int32 red, Int32 green, Int32 blue, Int32 alpha)
		{
			glColor4i(red, green, blue, alpha);
		}

		public static unsafe void Color4(Int32[] v)
		{
			fixed (Int32* ptr22 = &v[0]) { glColor4iv(new IntPtr(ptr22)); } 
		}

		public static unsafe void Color4(Int16 red, Int16 green, Int16 blue, Int16 alpha)
		{
			glColor4s(red, green, blue, alpha);
		}

		public static unsafe void Color4(Int16[] v)
		{
			fixed (Int16* ptr23 = &v[0]) { glColor4sv(new IntPtr(ptr23)); } 
		}

		public static unsafe void Color4(byte red, byte green, byte blue, byte alpha)
		{
			glColor4ub(red, green, blue, alpha);
		}

		public static unsafe void Color4(byte[] v)
		{
			fixed (byte* ptr24 = &v[0]) { glColor4ubv(new IntPtr(ptr24)); } 
		}

		public static unsafe void Color4(UInt32 red, UInt32 green, UInt32 blue, UInt32 alpha)
		{
			glColor4ui(red, green, blue, alpha);
		}

		public static unsafe void Color4(UInt32[] v)
		{
			fixed (UInt32* ptr25 = &v[0]) { glColor4uiv(new IntPtr(ptr25)); } 
		}

		public static unsafe void Color4(UInt16 red, UInt16 green, UInt16 blue, UInt16 alpha)
		{
			glColor4us(red, green, blue, alpha);
		}

		public static unsafe void Color4(UInt16[] v)
		{
			fixed (UInt16* ptr26 = &v[0]) { glColor4usv(new IntPtr(ptr26)); } 
		}

		public static unsafe void EdgeFlag(bool flag)
		{
			glEdgeFlag(flag ? ((byte)1) : ((byte)0));
		}

		public static unsafe void EdgeFlagv(bool[] flag)
		{
			fixed (bool* ptr27 = &flag[0]) { glEdgeFlagv(new IntPtr(ptr27)); } 
		}

		public static unsafe void End()
		{
			glEnd();
		}

		public static unsafe void Indexd(double c)
		{
			glIndexd(c);
		}

		public static unsafe void Indexdv(double[] c)
		{
			fixed (double* ptr28 = &c[0]) { glIndexdv(new IntPtr(ptr28)); } 
		}

		public static unsafe void Indexf(float c)
		{
			glIndexf(c);
		}

		public static unsafe void Indexfv(float[] c)
		{
			fixed (float* ptr29 = &c[0]) { glIndexfv(new IntPtr(ptr29)); } 
		}

		public static unsafe void Indexi(Int32 c)
		{
			glIndexi(c);
		}

		public static unsafe void Indexiv(Int32[] c)
		{
			fixed (Int32* ptr30 = &c[0]) { glIndexiv(new IntPtr(ptr30)); } 
		}

		public static unsafe void Indexs(Int16 c)
		{
			glIndexs(c);
		}

		public static unsafe void Indexsv(Int16[] c)
		{
			fixed (Int16* ptr31 = &c[0]) { glIndexsv(new IntPtr(ptr31)); } 
		}

		public static unsafe void Normal3b(SByte nx, SByte ny, SByte nz)
		{
			glNormal3b(nx, ny, nz);
		}

		public static unsafe void Normal3bv(SByte[] v)
		{
			fixed (SByte* ptr32 = &v[0]) { glNormal3bv(new IntPtr(ptr32)); } 
		}

		public static unsafe void Normal3d(double nx, double ny, double nz)
		{
			glNormal3d(nx, ny, nz);
		}

		public static unsafe void Normal3dv(double[] v)
		{
			fixed (double* ptr33 = &v[0]) { glNormal3dv(new IntPtr(ptr33)); } 
		}

		public static unsafe void Normal3f(float nx, float ny, float nz)
		{
			glNormal3f(nx, ny, nz);
		}

		public static unsafe void Normal3fv(float[] v)
		{
			fixed (float* ptr34 = &v[0]) { glNormal3fv(new IntPtr(ptr34)); } 
		}

		public static unsafe void Normal3i(Int32 nx, Int32 ny, Int32 nz)
		{
			glNormal3i(nx, ny, nz);
		}

		public static unsafe void Normal3iv(Int32[] v)
		{
			fixed (Int32* ptr35 = &v[0]) { glNormal3iv(new IntPtr(ptr35)); } 
		}

		public static unsafe void Normal3s(Int16 nx, Int16 ny, Int16 nz)
		{
			glNormal3s(nx, ny, nz);
		}

		public static unsafe void Normal3sv(Int16[] v)
		{
			fixed (Int16* ptr36 = &v[0]) { glNormal3sv(new IntPtr(ptr36)); } 
		}

		public static unsafe void RasterPos2d(double x, double y)
		{
			glRasterPos2d(x, y);
		}

		public static unsafe void RasterPos2dv(double[] v)
		{
			fixed (double* ptr37 = &v[0]) { glRasterPos2dv(new IntPtr(ptr37)); } 
		}

		public static unsafe void RasterPos2f(float x, float y)
		{
			glRasterPos2f(x, y);
		}

		public static unsafe void RasterPos2fv(float[] v)
		{
			fixed (float* ptr38 = &v[0]) { glRasterPos2fv(new IntPtr(ptr38)); } 
		}

		public static unsafe void RasterPos2i(Int32 x, Int32 y)
		{
			glRasterPos2i(x, y);
		}

		public static unsafe void RasterPos2iv(Int32[] v)
		{
			fixed (Int32* ptr39 = &v[0]) { glRasterPos2iv(new IntPtr(ptr39)); } 
		}

		public static unsafe void RasterPos2s(Int16 x, Int16 y)
		{
			glRasterPos2s(x, y);
		}

		public static unsafe void RasterPos2sv(Int16[] v)
		{
			fixed (Int16* ptr40 = &v[0]) { glRasterPos2sv(new IntPtr(ptr40)); } 
		}

		public static unsafe void RasterPos3d(double x, double y, double z)
		{
			glRasterPos3d(x, y, z);
		}

		public static unsafe void RasterPos3dv(double[] v)
		{
			fixed (double* ptr41 = &v[0]) { glRasterPos3dv(new IntPtr(ptr41)); } 
		}

		public static unsafe void RasterPos3f(float x, float y, float z)
		{
			glRasterPos3f(x, y, z);
		}

		public static unsafe void RasterPos3fv(float[] v)
		{
			fixed (float* ptr42 = &v[0]) { glRasterPos3fv(new IntPtr(ptr42)); } 
		}

		public static unsafe void RasterPos3i(Int32 x, Int32 y, Int32 z)
		{
			glRasterPos3i(x, y, z);
		}

		public static unsafe void RasterPos3iv(Int32[] v)
		{
			fixed (Int32* ptr43 = &v[0]) { glRasterPos3iv(new IntPtr(ptr43)); } 
		}

		public static unsafe void RasterPos3s(Int16 x, Int16 y, Int16 z)
		{
			glRasterPos3s(x, y, z);
		}

		public static unsafe void RasterPos3sv(Int16[] v)
		{
			fixed (Int16* ptr44 = &v[0]) { glRasterPos3sv(new IntPtr(ptr44)); } 
		}

		public static unsafe void RasterPos4d(double x, double y, double z, double w)
		{
			glRasterPos4d(x, y, z, w);
		}

		public static unsafe void RasterPos4dv(double[] v)
		{
			fixed (double* ptr45 = &v[0]) { glRasterPos4dv(new IntPtr(ptr45)); } 
		}

		public static unsafe void RasterPos4f(float x, float y, float z, float w)
		{
			glRasterPos4f(x, y, z, w);
		}

		public static unsafe void RasterPos4fv(float[] v)
		{
			fixed (float* ptr46 = &v[0]) { glRasterPos4fv(new IntPtr(ptr46)); } 
		}

		public static unsafe void RasterPos4i(Int32 x, Int32 y, Int32 z, Int32 w)
		{
			glRasterPos4i(x, y, z, w);
		}

		public static unsafe void RasterPos4iv(Int32[] v)
		{
			fixed (Int32* ptr47 = &v[0]) { glRasterPos4iv(new IntPtr(ptr47)); } 
		}

		public static unsafe void RasterPos4s(Int16 x, Int16 y, Int16 z, Int16 w)
		{
			glRasterPos4s(x, y, z, w);
		}

		public static unsafe void RasterPos4sv(Int16[] v)
		{
			fixed (Int16* ptr48 = &v[0]) { glRasterPos4sv(new IntPtr(ptr48)); } 
		}

		public static unsafe void Rectd(double x1, double y1, double x2, double y2)
		{
			glRectd(x1, y1, x2, y2);
		}

		public static unsafe void Rectdv(double[] v1, double[] v2)
		{
			fixed (double* ptr50 = &v2[0]) { fixed (double* ptr49 = &v1[0]) { glRectdv(new IntPtr(ptr49), new IntPtr(ptr50)); }  } 
		}

		public static unsafe void Rectf(float x1, float y1, float x2, float y2)
		{
			glRectf(x1, y1, x2, y2);
		}

		public static unsafe void Rectfv(float[] v1, float[] v2)
		{
			fixed (float* ptr52 = &v2[0]) { fixed (float* ptr51 = &v1[0]) { glRectfv(new IntPtr(ptr51), new IntPtr(ptr52)); }  } 
		}

		public static unsafe void Recti(Int32 x1, Int32 y1, Int32 x2, Int32 y2)
		{
			glRecti(x1, y1, x2, y2);
		}

		public static unsafe void Rectiv(Int32[] v1, Int32[] v2)
		{
			fixed (Int32* ptr54 = &v2[0]) { fixed (Int32* ptr53 = &v1[0]) { glRectiv(new IntPtr(ptr53), new IntPtr(ptr54)); }  } 
		}

		public static unsafe void Rects(Int16 x1, Int16 y1, Int16 x2, Int16 y2)
		{
			glRects(x1, y1, x2, y2);
		}

		public static unsafe void Rectsv(Int16[] v1, Int16[] v2)
		{
			fixed (Int16* ptr56 = &v2[0]) { fixed (Int16* ptr55 = &v1[0]) { glRectsv(new IntPtr(ptr55), new IntPtr(ptr56)); }  } 
		}

		public static unsafe void TexCoord1d(double s)
		{
			glTexCoord1d(s);
		}

		public static unsafe void TexCoord1dv(double[] v)
		{
			fixed (double* ptr57 = &v[0]) { glTexCoord1dv(new IntPtr(ptr57)); } 
		}

		public static unsafe void TexCoord1f(float s)
		{
			glTexCoord1f(s);
		}

		public static unsafe void TexCoord1fv(float[] v)
		{
			fixed (float* ptr58 = &v[0]) { glTexCoord1fv(new IntPtr(ptr58)); } 
		}

		public static unsafe void TexCoord1i(Int32 s)
		{
			glTexCoord1i(s);
		}

		public static unsafe void TexCoord1iv(Int32[] v)
		{
			fixed (Int32* ptr59 = &v[0]) { glTexCoord1iv(new IntPtr(ptr59)); } 
		}

		public static unsafe void TexCoord1s(Int16 s)
		{
			glTexCoord1s(s);
		}

		public static unsafe void TexCoord1sv(Int16[] v)
		{
			fixed (Int16* ptr60 = &v[0]) { glTexCoord1sv(new IntPtr(ptr60)); } 
		}

		public static unsafe void TexCoord2(double s, double t)
		{
			glTexCoord2d(s, t);
		}

		public static unsafe void TexCoord2(double[] v)
		{
			fixed (double* ptr61 = &v[0]) { glTexCoord2dv(new IntPtr(ptr61)); } 
		}

		public static unsafe void TexCoord2(float s, float t)
		{
			glTexCoord2f(s, t);
		}

		public static unsafe void TexCoord2(float[] v)
		{
			fixed (float* ptr62 = &v[0]) { glTexCoord2fv(new IntPtr(ptr62)); } 
		}

		public static unsafe void TexCoord2(Int32 s, Int32 t)
		{
			glTexCoord2i(s, t);
		}

		public static unsafe void TexCoord2(Int32[] v)
		{
			fixed (Int32* ptr63 = &v[0]) { glTexCoord2iv(new IntPtr(ptr63)); } 
		}

		public static unsafe void TexCoord2(Int16 s, Int16 t)
		{
			glTexCoord2s(s, t);
		}

		public static unsafe void TexCoord2(Int16[] v)
		{
			fixed (Int16* ptr64 = &v[0]) { glTexCoord2sv(new IntPtr(ptr64)); } 
		}

		public static unsafe void TexCoord3(double s, double t, double r)
		{
			glTexCoord3d(s, t, r);
		}

		public static unsafe void TexCoord3(double[] v)
		{
			fixed (double* ptr65 = &v[0]) { glTexCoord3dv(new IntPtr(ptr65)); } 
		}

		public static unsafe void TexCoord3(float s, float t, float r)
		{
			glTexCoord3f(s, t, r);
		}

		public static unsafe void TexCoord3(float[] v)
		{
			fixed (float* ptr66 = &v[0]) { glTexCoord3fv(new IntPtr(ptr66)); } 
		}

		public static unsafe void TexCoord3(Int32 s, Int32 t, Int32 r)
		{
			glTexCoord3i(s, t, r);
		}

		public static unsafe void TexCoord3(Int32[] v)
		{
			fixed (Int32* ptr67 = &v[0]) { glTexCoord3iv(new IntPtr(ptr67)); } 
		}

		public static unsafe void TexCoord3(Int16 s, Int16 t, Int16 r)
		{
			glTexCoord3s(s, t, r);
		}

		public static unsafe void TexCoord3(Int16[] v)
		{
			fixed (Int16* ptr68 = &v[0]) { glTexCoord3sv(new IntPtr(ptr68)); } 
		}

		public static unsafe void TexCoord4(double s, double t, double r, double q)
		{
			glTexCoord4d(s, t, r, q);
		}

		public static unsafe void TexCoord4(double[] v)
		{
			fixed (double* ptr69 = &v[0]) { glTexCoord4dv(new IntPtr(ptr69)); } 
		}

		public static unsafe void TexCoord4(float s, float t, float r, float q)
		{
			glTexCoord4f(s, t, r, q);
		}

		public static unsafe void TexCoord4(float[] v)
		{
			fixed (float* ptr70 = &v[0]) { glTexCoord4fv(new IntPtr(ptr70)); } 
		}

		public static unsafe void TexCoord4(Int32 s, Int32 t, Int32 r, Int32 q)
		{
			glTexCoord4i(s, t, r, q);
		}

		public static unsafe void TexCoord4(Int32[] v)
		{
			fixed (Int32* ptr71 = &v[0]) { glTexCoord4iv(new IntPtr(ptr71)); } 
		}

		public static unsafe void TexCoord4(Int16 s, Int16 t, Int16 r, Int16 q)
		{
			glTexCoord4s(s, t, r, q);
		}

		public static unsafe void TexCoord4(Int16[] v)
		{
			fixed (Int16* ptr72 = &v[0]) { glTexCoord4sv(new IntPtr(ptr72)); } 
		}

		public static unsafe void Vertex2(double x, double y)
		{
			glVertex2d(x, y);
		}

		public static unsafe void Vertex2(double[] v)
		{
			fixed (double* ptr73 = &v[0]) { glVertex2dv(new IntPtr(ptr73)); } 
		}

		public static unsafe void Vertex2(float x, float y)
		{
			glVertex2f(x, y);
		}

		public static unsafe void Vertex2(float[] v)
		{
			fixed (float* ptr74 = &v[0]) { glVertex2fv(new IntPtr(ptr74)); } 
		}

		public static unsafe void Vertex2(Int32 x, Int32 y)
		{
			glVertex2i(x, y);
		}

		public static unsafe void Vertex2(Int32[] v)
		{
			fixed (Int32* ptr75 = &v[0]) { glVertex2iv(new IntPtr(ptr75)); } 
		}

		public static unsafe void Vertex2(Int16 x, Int16 y)
		{
			glVertex2s(x, y);
		}

		public static unsafe void Vertex2(Int16[] v)
		{
			fixed (Int16* ptr76 = &v[0]) { glVertex2sv(new IntPtr(ptr76)); } 
		}

		public static unsafe void Vertex3(double x, double y, double z)
		{
			glVertex3d(x, y, z);
		}

		public static unsafe void Vertex3(double[] v)
		{
			fixed (double* ptr77 = &v[0]) { glVertex3dv(new IntPtr(ptr77)); } 
		}

		public static unsafe void Vertex3(float x, float y, float z)
		{
			glVertex3f(x, y, z);
		}

		public static unsafe void Vertex3(float[] v)
		{
			fixed (float* ptr78 = &v[0]) { glVertex3fv(new IntPtr(ptr78)); } 
		}

		public static unsafe void Vertex3(Int32 x, Int32 y, Int32 z)
		{
			glVertex3i(x, y, z);
		}

		public static unsafe void Vertex3(Int32[] v)
		{
			fixed (Int32* ptr79 = &v[0]) { glVertex3iv(new IntPtr(ptr79)); } 
		}

		public static unsafe void Vertex3(Int16 x, Int16 y, Int16 z)
		{
			glVertex3s(x, y, z);
		}

		public static unsafe void Vertex3(Int16[] v)
		{
			fixed (Int16* ptr80 = &v[0]) { glVertex3sv(new IntPtr(ptr80)); } 
		}

		public static unsafe void Vertex4(double x, double y, double z, double w)
		{
			glVertex4d(x, y, z, w);
		}

		public static unsafe void Vertex4(double[] v)
		{
			fixed (double* ptr81 = &v[0]) { glVertex4dv(new IntPtr(ptr81)); } 
		}

		public static unsafe void Vertex4(float x, float y, float z, float w)
		{
			glVertex4f(x, y, z, w);
		}

		public static unsafe void Vertex4(float[] v)
		{
			fixed (float* ptr82 = &v[0]) { glVertex4fv(new IntPtr(ptr82)); } 
		}

		public static unsafe void Vertex4(Int32 x, Int32 y, Int32 z, Int32 w)
		{
			glVertex4i(x, y, z, w);
		}

		public static unsafe void Vertex4(Int32[] v)
		{
			fixed (Int32* ptr83 = &v[0]) { glVertex4iv(new IntPtr(ptr83)); } 
		}

		public static unsafe void Vertex4(Int16 x, Int16 y, Int16 z, Int16 w)
		{
			glVertex4s(x, y, z, w);
		}

		public static unsafe void Vertex4(Int16[] v)
		{
			fixed (Int16* ptr84 = &v[0]) { glVertex4sv(new IntPtr(ptr84)); } 
		}

		public static unsafe void ClipPlane(ClipPlaneName plane, double[] equation)
		{
			fixed (double* ptr85 = &equation[0]) { glClipPlane((uint)plane, new IntPtr(ptr85)); } 
		}

		public static unsafe void ColorMaterial(MaterialFace face, ColorMaterialParameter mode)
		{
			glColorMaterial((uint)face, (uint)mode);
		}

		public static unsafe void Fogf(FogParameter pname, float param)
		{
			glFogf((uint)pname, param);
		}

		public static unsafe void Fogfv(FogParameter pname, float[] parameters)
		{
			fixed (float* ptr86 = &parameters[0]) { glFogfv((uint)pname, new IntPtr(ptr86)); } 
		}

		public static unsafe void Fogi(FogParameter pname, Int32 param)
		{
			glFogi((uint)pname, param);
		}

		public static unsafe void Fogiv(FogParameter pname, Int32[] parameters)
		{
			fixed (Int32* ptr87 = &parameters[0]) { glFogiv((uint)pname, new IntPtr(ptr87)); } 
		}

		public static unsafe void Lightf(LightName light, LightParameter pname, float param)
		{
			glLightf((uint)light, (uint)pname, param);
		}

		public static unsafe void Lightfv(LightName light, LightParameter pname, float[] parameters)
		{
			fixed (float* ptr88 = &parameters[0]) { glLightfv((uint)light, (uint)pname, new IntPtr(ptr88)); } 
		}

		public static unsafe void Lighti(LightName light, LightParameter pname, Int32 param)
		{
			glLighti((uint)light, (uint)pname, param);
		}

		public static unsafe void Lightiv(LightName light, LightParameter pname, Int32[] parameters)
		{
			fixed (Int32* ptr89 = &parameters[0]) { glLightiv((uint)light, (uint)pname, new IntPtr(ptr89)); } 
		}

		public static unsafe void LightModelf(LightModelParameter pname, float param)
		{
			glLightModelf((uint)pname, param);
		}

		public static unsafe void LightModelfv(LightModelParameter pname, float[] parameters)
		{
			fixed (float* ptr90 = &parameters[0]) { glLightModelfv((uint)pname, new IntPtr(ptr90)); } 
		}

		public static unsafe void LightModeli(LightModelParameter pname, Int32 param)
		{
			glLightModeli((uint)pname, param);
		}

		public static unsafe void LightModeliv(LightModelParameter pname, Int32[] parameters)
		{
			fixed (Int32* ptr91 = &parameters[0]) { glLightModeliv((uint)pname, new IntPtr(ptr91)); } 
		}

		public static unsafe void LineStipple(Int32 factor, UInt16 pattern)
		{
			glLineStipple(factor, pattern);
		}

		public static unsafe void Materialf(MaterialFace face, MaterialParameter pname, float param)
		{
			glMaterialf((uint)face, (uint)pname, param);
		}

		public static unsafe void Materialfv(MaterialFace face, MaterialParameter pname, float[] parameters)
		{
			fixed (float* ptr92 = &parameters[0]) { glMaterialfv((uint)face, (uint)pname, new IntPtr(ptr92)); } 
		}

		public static unsafe void Materiali(MaterialFace face, MaterialParameter pname, Int32 param)
		{
			glMateriali((uint)face, (uint)pname, param);
		}

		public static unsafe void Materialiv(MaterialFace face, MaterialParameter pname, Int32[] parameters)
		{
			fixed (Int32* ptr93 = &parameters[0]) { glMaterialiv((uint)face, (uint)pname, new IntPtr(ptr93)); } 
		}

		public static unsafe void PolygonStipple(byte[] mask)
		{
			fixed (byte* ptr94 = &mask[0]) { glPolygonStipple(new IntPtr(ptr94)); } 
		}

		public static unsafe void ShadeModel(ShadingModel mode)
		{
			glShadeModel((uint)mode);
		}

		public static unsafe void TexEnvf(TextureEnvTarget target, TextureEnvParameter pname, float param)
		{
			glTexEnvf((uint)target, (uint)pname, param);
		}

		public static unsafe void TexEnvfv(TextureEnvTarget target, TextureEnvParameter pname, float[] parameters)
		{
			fixed (float* ptr95 = &parameters[0]) { glTexEnvfv((uint)target, (uint)pname, new IntPtr(ptr95)); } 
		}

		public static unsafe void TexEnvi(TextureEnvTarget target, TextureEnvParameter pname, Int32 param)
		{
			glTexEnvi((uint)target, (uint)pname, param);
		}

		public static unsafe void TexEnviv(TextureEnvTarget target, TextureEnvParameter pname, Int32[] parameters)
		{
			fixed (Int32* ptr96 = &parameters[0]) { glTexEnviv((uint)target, (uint)pname, new IntPtr(ptr96)); } 
		}

		public static unsafe void TexGend(TextureCoordName coord, TextureGenParameter pname, double param)
		{
			glTexGend((uint)coord, (uint)pname, param);
		}

		public static unsafe void TexGendv(TextureCoordName coord, TextureGenParameter pname, double[] parameters)
		{
			fixed (double* ptr97 = &parameters[0]) { glTexGendv((uint)coord, (uint)pname, new IntPtr(ptr97)); } 
		}

		public static unsafe void TexGenf(TextureCoordName coord, TextureGenParameter pname, float param)
		{
			glTexGenf((uint)coord, (uint)pname, param);
		}

		public static unsafe void TexGenfv(TextureCoordName coord, TextureGenParameter pname, float[] parameters)
		{
			fixed (float* ptr98 = &parameters[0]) { glTexGenfv((uint)coord, (uint)pname, new IntPtr(ptr98)); } 
		}

		public static unsafe void TexGeni(TextureCoordName coord, TextureGenParameter pname, Int32 param)
		{
			glTexGeni((uint)coord, (uint)pname, param);
		}

		public static unsafe void TexGeniv(TextureCoordName coord, TextureGenParameter pname, Int32[] parameters)
		{
			fixed (Int32* ptr99 = &parameters[0]) { glTexGeniv((uint)coord, (uint)pname, new IntPtr(ptr99)); } 
		}

		public static unsafe void FeedbackBuffer(Int32 size, FeedbackType type, [OutAttribute] float[] buffer)
		{
			fixed (float* optr100 = buffer) { glFeedbackBuffer(size, (uint)type, optr100); } 
		}

		public static unsafe void SelectBuffer(Int32 size, [OutAttribute] UInt32[] buffer)
		{
			fixed (UInt32* optr101 = buffer) { glSelectBuffer(size, optr101); } 
		}

		public static unsafe Int32 RenderMode(RenderingMode mode)
		{
			return glRenderMode((uint)mode);
		}

		public static unsafe void InitNames()
		{
			glInitNames();
		}

		public static unsafe void LoadName(UInt32 name)
		{
			glLoadName(name);
		}

		public static unsafe void PassThrough(float token)
		{
			glPassThrough(token);
		}

		public static unsafe void PopName()
		{
			glPopName();
		}

		public static unsafe void PushName(UInt32 name)
		{
			glPushName(name);
		}

		public static unsafe void ClearAccum(float red, float green, float blue, float alpha)
		{
			glClearAccum(red, green, blue, alpha);
		}

		public static unsafe void ClearIndex(float c)
		{
			glClearIndex(c);
		}

		public static unsafe void IndexMask(UInt32 mask)
		{
			glIndexMask(mask);
		}

		public static unsafe void Accum(AccumOp op, float val)
		{
			glAccum((uint)op, val);
		}

		public static unsafe void PopAttrib()
		{
			glPopAttrib();
		}

		public static unsafe void PushAttrib(UInt32 mask)
		{
			glPushAttrib(mask);
		}

		public static unsafe void Map1d(MapTarget target, double u1, double u2, Int32 stride, Int32 order, double[] points)
		{
			fixed (double* ptr102 = &points[0]) { glMap1d((uint)target, u1, u2, stride, order, new IntPtr(ptr102)); } 
		}

		public static unsafe void Map1f(MapTarget target, float u1, float u2, Int32 stride, Int32 order, float[] points)
		{
			fixed (float* ptr103 = &points[0]) { glMap1f((uint)target, u1, u2, stride, order, new IntPtr(ptr103)); } 
		}

		public static unsafe void Map2d(MapTarget target, double u1, double u2, Int32 ustride, Int32 uorder, double v1, double v2, Int32 vstride, Int32 vorder, double[] points)
		{
			fixed (double* ptr104 = &points[0]) { glMap2d((uint)target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, new IntPtr(ptr104)); } 
		}

		public static unsafe void Map2f(MapTarget target, float u1, float u2, Int32 ustride, Int32 uorder, float v1, float v2, Int32 vstride, Int32 vorder, float[] points)
		{
			fixed (float* ptr105 = &points[0]) { glMap2f((uint)target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, new IntPtr(ptr105)); } 
		}

		public static unsafe void MapGrid1d(Int32 un, double u1, double u2)
		{
			glMapGrid1d(un, u1, u2);
		}

		public static unsafe void MapGrid1f(Int32 un, float u1, float u2)
		{
			glMapGrid1f(un, u1, u2);
		}

		public static unsafe void MapGrid2d(Int32 un, double u1, double u2, Int32 vn, double v1, double v2)
		{
			glMapGrid2d(un, u1, u2, vn, v1, v2);
		}

		public static unsafe void MapGrid2f(Int32 un, float u1, float u2, Int32 vn, float v1, float v2)
		{
			glMapGrid2f(un, u1, u2, vn, v1, v2);
		}

		public static unsafe void EvalCoord1d(double u)
		{
			glEvalCoord1d(u);
		}

		public static unsafe void EvalCoord1dv(double[] u)
		{
			fixed (double* ptr106 = &u[0]) { glEvalCoord1dv(new IntPtr(ptr106)); } 
		}

		public static unsafe void EvalCoord1f(float u)
		{
			glEvalCoord1f(u);
		}

		public static unsafe void EvalCoord1fv(float[] u)
		{
			fixed (float* ptr107 = &u[0]) { glEvalCoord1fv(new IntPtr(ptr107)); } 
		}

		public static unsafe void EvalCoord2d(double u, double v)
		{
			glEvalCoord2d(u, v);
		}

		public static unsafe void EvalCoord2dv(double[] u)
		{
			fixed (double* ptr108 = &u[0]) { glEvalCoord2dv(new IntPtr(ptr108)); } 
		}

		public static unsafe void EvalCoord2f(float u, float v)
		{
			glEvalCoord2f(u, v);
		}

		public static unsafe void EvalCoord2fv(float[] u)
		{
			fixed (float* ptr109 = &u[0]) { glEvalCoord2fv(new IntPtr(ptr109)); } 
		}

		public static unsafe void EvalMesh1(MeshMode1 mode, Int32 i1, Int32 i2)
		{
			glEvalMesh1((uint)mode, i1, i2);
		}

		public static unsafe void EvalPoint1(Int32 i)
		{
			glEvalPoint1(i);
		}

		public static unsafe void EvalMesh2(MeshMode2 mode, Int32 i1, Int32 i2, Int32 j1, Int32 j2)
		{
			glEvalMesh2((uint)mode, i1, i2, j1, j2);
		}

		public static unsafe void EvalPoint2(Int32 i, Int32 j)
		{
			glEvalPoint2(i, j);
		}

		public static unsafe void AlphaFunc(AlphaFunction func, float reference)
		{
			glAlphaFunc((uint)func, reference);
		}

		public static unsafe void PixelZoom(float xfactor, float yfactor)
		{
			glPixelZoom(xfactor, yfactor);
		}

		public static unsafe void PixelTransferf(PixelTransferParameter pname, float param)
		{
			glPixelTransferf((uint)pname, param);
		}

		public static unsafe void PixelTransferi(PixelTransferParameter pname, Int32 param)
		{
			glPixelTransferi((uint)pname, param);
		}

		public static unsafe void PixelMapfv(PixelMap map, Int32 mapsize, float[] values)
		{
			fixed (float* ptr110 = &values[0]) { glPixelMapfv((uint)map, mapsize, new IntPtr(ptr110)); } 
		}

		public static unsafe void PixelMapuiv(PixelMap map, Int32 mapsize, UInt32[] values)
		{
			fixed (UInt32* ptr111 = &values[0]) { glPixelMapuiv((uint)map, mapsize, new IntPtr(ptr111)); } 
		}

		public static unsafe void PixelMapusv(PixelMap map, Int32 mapsize, UInt16[] values)
		{
			fixed (UInt16* ptr112 = &values[0]) { glPixelMapusv((uint)map, mapsize, new IntPtr(ptr112)); } 
		}

		public static unsafe void CopyPixels(Int32 x, Int32 y, Int32 width, Int32 height, PixelCopyType type)
		{
			glCopyPixels(x, y, width, height, (uint)type);
		}

		public static unsafe void DrawPixels(Int32 width, Int32 height, PixelFormat format, PixelType type, IntPtr pixels)
		{
			glDrawPixels(width, height, (uint)format, (uint)type, pixels);
		}

		public static unsafe void GetClipPlane(ClipPlaneName plane, [OutAttribute] double[] equation)
		{
			fixed (double* optr113 = equation) { glGetClipPlane((uint)plane, optr113); } 
		}

		public static unsafe void GetLightfv(LightName light, LightParameter pname, [OutAttribute] float[] parameters)
		{
			fixed (float* optr114 = parameters) { glGetLightfv((uint)light, (uint)pname, optr114); } 
		}

		public static unsafe void GetLightiv(LightName light, LightParameter pname, [OutAttribute] Int32[] parameters)
		{
			fixed (Int32* optr115 = parameters) { glGetLightiv((uint)light, (uint)pname, optr115); } 
		}

		public static unsafe void GetMapdv(MapTarget target, GetMapQuery query, [OutAttribute] double[] v)
		{
			fixed (double* optr116 = v) { glGetMapdv((uint)target, (uint)query, optr116); } 
		}

		public static unsafe void GetMapfv(MapTarget target, GetMapQuery query, [OutAttribute] float[] v)
		{
			fixed (float* optr117 = v) { glGetMapfv((uint)target, (uint)query, optr117); } 
		}

		public static unsafe void GetMapiv(MapTarget target, GetMapQuery query, [OutAttribute] Int32[] v)
		{
			fixed (Int32* optr118 = v) { glGetMapiv((uint)target, (uint)query, optr118); } 
		}

		public static unsafe void GetMaterialfv(MaterialFace face, MaterialParameter pname, [OutAttribute] float[] parameters)
		{
			fixed (float* optr119 = parameters) { glGetMaterialfv((uint)face, (uint)pname, optr119); } 
		}

		public static unsafe void GetMaterialiv(MaterialFace face, MaterialParameter pname, [OutAttribute] Int32[] parameters)
		{
			fixed (Int32* optr120 = parameters) { glGetMaterialiv((uint)face, (uint)pname, optr120); } 
		}

		public static unsafe void GetPixelMapfv(PixelMap map, [OutAttribute] float[] values)
		{
			fixed (float* optr121 = values) { glGetPixelMapfv((uint)map, optr121); } 
		}

		public static unsafe void GetPixelMapuiv(PixelMap map, [OutAttribute] UInt32[] values)
		{
			fixed (UInt32* optr122 = values) { glGetPixelMapuiv((uint)map, optr122); } 
		}

		public static unsafe void GetPixelMapusv(PixelMap map, [OutAttribute] UInt16[] values)
		{
			fixed (UInt16* optr123 = values) { glGetPixelMapusv((uint)map, optr123); } 
		}

		public static unsafe void GetPolygonStipple([OutAttribute] byte[] mask)
		{
			fixed (byte* optr124 = mask) { glGetPolygonStipple(optr124); } 
		}

		public static unsafe void GetTexEnvfv(TextureEnvTarget target, TextureEnvParameter pname, [OutAttribute] float[] parameters)
		{
			fixed (float* optr125 = parameters) { glGetTexEnvfv((uint)target, (uint)pname, optr125); } 
		}

		public static unsafe void GetTexEnviv(TextureEnvTarget target, TextureEnvParameter pname, [OutAttribute] Int32[] parameters)
		{
			fixed (Int32* optr126 = parameters) { glGetTexEnviv((uint)target, (uint)pname, optr126); } 
		}

		public static unsafe void GetTexGendv(TextureCoordName coord, TextureGenParameter pname, [OutAttribute] double[] parameters)
		{
			fixed (double* optr127 = parameters) { glGetTexGendv((uint)coord, (uint)pname, optr127); } 
		}

		public static unsafe void GetTexGenfv(TextureCoordName coord, TextureGenParameter pname, [OutAttribute] float[] parameters)
		{
			fixed (float* optr128 = parameters) { glGetTexGenfv((uint)coord, (uint)pname, optr128); } 
		}

		public static unsafe void GetTexGeniv(TextureCoordName coord, TextureGenParameter pname, [OutAttribute] Int32[] parameters)
		{
			fixed (Int32* optr129 = parameters) { glGetTexGeniv((uint)coord, (uint)pname, optr129); } 
		}

		public static unsafe bool IsList(UInt32 list)
		{
			return (glIsList(list) == 1);
		}

		public static unsafe void Frustum(double left, double right, double bottom, double top, double zNear, double zFar)
		{
			glFrustum(left, right, bottom, top, zNear, zFar);
		}

		public static unsafe void LoadIdentity()
		{
			glLoadIdentity();
		}

		public static unsafe void LoadMatrixf(float[] m)
		{
			fixed (float* ptr130 = &m[0]) { glLoadMatrixf(new IntPtr(ptr130)); } 
		}

		public static unsafe void LoadMatrixd(double[] m)
		{
			fixed (double* ptr131 = &m[0]) { glLoadMatrixd(new IntPtr(ptr131)); } 
		}

		public static unsafe void MatrixMode(MatrixMode mode)
		{
			glMatrixMode((uint)mode);
		}

		public static unsafe void MultMatrixf(float[] m)
		{
			fixed (float* ptr132 = &m[0]) { glMultMatrixf(new IntPtr(ptr132)); } 
		}

		public static unsafe void MultMatrixd(double[] m)
		{
			fixed (double* ptr133 = &m[0]) { glMultMatrixd(new IntPtr(ptr133)); } 
		}

		public static unsafe void Ortho(double left, double right, double bottom, double top, double zNear, double zFar)
		{
			glOrtho(left, right, bottom, top, zNear, zFar);
		}

		public static unsafe void PopMatrix()
		{
			glPopMatrix();
		}

		public static unsafe void PushMatrix()
		{
			glPushMatrix();
		}

		public static unsafe void Rotate(double angle, double x, double y, double z)
		{
			glRotated(angle, x, y, z);
		}

		public static unsafe void Rotate(float angle, float x, float y, float z)
		{
			glRotatef(angle, x, y, z);
		}

		public static unsafe void Scale(double x, double y, double z)
		{
			glScaled(x, y, z);
		}

		public static unsafe void Scale(float x, float y, float z)
		{
			glScalef(x, y, z);
		}

		public static unsafe void Translate(double x, double y, double z)
		{
			glTranslated(x, y, z);
		}

		public static unsafe void Translate(float x, float y, float z)
		{
			glTranslatef(x, y, z);
		}

		public static unsafe void DrawArrays(BeginMode mode, Int32 first, Int32 count)
		{
			glDrawArrays((uint)mode, first, count);
		}

		public static unsafe void DrawElements(BeginMode mode, Int32 count, GLEnum type, IntPtr indices)
		{
			glDrawElements((uint)mode, count, (uint)type, indices);
		}

		public static unsafe void GetPointerv(GetPointervPName pname, [OutAttribute] IntPtr[] parameters)
		{
			fixed (IntPtr* optr134 = parameters) { glGetPointerv((uint)pname, optr134); } 
		}

		public static unsafe void PolygonOffset(float factor, float units)
		{
			glPolygonOffset(factor, units);
		}

		public static unsafe void CopyTexImage1D(TextureTarget target, Int32 level, PixelInternalFormat internalformat, Int32 x, Int32 y, Int32 width, Int32 border)
		{
			glCopyTexImage1D((uint)target, level, (uint)internalformat, x, y, width, border);
		}

		public static unsafe void CopyTexImage2D(TextureTarget target, Int32 level, PixelInternalFormat internalformat, Int32 x, Int32 y, Int32 width, Int32 height, Int32 border)
		{
			glCopyTexImage2D((uint)target, level, (uint)internalformat, x, y, width, height, border);
		}

		public static unsafe void CopyTexSubImage1D(TextureTarget target, Int32 level, Int32 xoffset, Int32 x, Int32 y, Int32 width)
		{
			glCopyTexSubImage1D((uint)target, level, xoffset, x, y, width);
		}

		public static unsafe void CopyTexSubImage2D(TextureTarget target, Int32 level, Int32 xoffset, Int32 yoffset, Int32 x, Int32 y, Int32 width, Int32 height)
		{
			glCopyTexSubImage2D((uint)target, level, xoffset, yoffset, x, y, width, height);
		}

		public static unsafe void TexSubImage1D(TextureTarget target, Int32 level, Int32 xoffset, Int32 width, PixelFormat format, PixelType type, IntPtr pixels)
		{
			glTexSubImage1D((uint)target, level, xoffset, width, (uint)format, (uint)type, pixels);
		}

		public static unsafe void TexSubImage2D(TextureTarget target, Int32 level, Int32 xoffset, Int32 yoffset, Int32 width, Int32 height, PixelFormat format, PixelType type, IntPtr pixels)
		{
			glTexSubImage2D((uint)target, level, xoffset, yoffset, width, height, (uint)format, (uint)type, pixels);
		}

		public static unsafe void BindTexture(TextureTarget target, UInt32 texture)
		{
			glBindTexture((uint)target, texture);
		}

		public static unsafe void DeleteTextures(Int32 n, UInt32[] textures)
		{
			fixed (UInt32* ptr135 = &textures[0]) { glDeleteTextures(n, new IntPtr(ptr135)); } 
		}

		public static unsafe void GenTextures(Int32 n, [OutAttribute] UInt32[] textures)
		{
			fixed (UInt32* optr136 = textures) { glGenTextures(n, optr136); } 
		}

		public static unsafe bool IsTexture(UInt32 texture)
		{
			return (glIsTexture(texture) == 1);
		}

		public static unsafe void ArrayElement(Int32 i)
		{
			glArrayElement(i);
		}

		public static unsafe void ColorPointer(Int32 size, ColorPointerType type, Int32 stride, IntPtr pointer)
		{
			glColorPointer(size, (uint)type, stride, pointer);
		}

		public static unsafe void DisableClientState(EnableCap array)
		{
			glDisableClientState((uint)array);
		}

		public static unsafe void EdgeFlagPointer(Int32 stride, IntPtr pointer)
		{
			glEdgeFlagPointer(stride, pointer);
		}

		public static unsafe void EnableClientState(EnableCap array)
		{
			glEnableClientState((uint)array);
		}

		public static unsafe void IndexPointer(IndexPointerType type, Int32 stride, IntPtr pointer)
		{
			glIndexPointer((uint)type, stride, pointer);
		}

		public static unsafe void InterleavedArrays(InterleavedArrayFormat format, Int32 stride, IntPtr pointer)
		{
			glInterleavedArrays((uint)format, stride, pointer);
		}

		public static unsafe void NormalPointer(NormalPointerType type, Int32 stride, IntPtr pointer)
		{
			glNormalPointer((uint)type, stride, pointer);
		}

		public static unsafe void TexCoordPointer(Int32 size, TexCoordPointerType type, Int32 stride, IntPtr pointer)
		{
			glTexCoordPointer(size, (uint)type, stride, pointer);
		}

		public static unsafe void VertexPointer(Int32 size, VertexPointerType type, Int32 stride, IntPtr pointer)
		{
			glVertexPointer(size, (uint)type, stride, pointer);
		}

		public static unsafe bool AreTexturesResident(Int32 n, UInt32[] textures, [OutAttribute] bool[] residences)
		{
			bool retVal;
			byte[] btr138 = new byte[1];
			fixed (byte* optr138 = btr138) { fixed (UInt32* ptr137 = &textures[0]) { retVal = (glAreTexturesResident(n, new IntPtr(ptr137), optr138) == 1); }  }
			residences = new bool[btr138.Length];
			for (int i138 = 0; i138< residences.Length; i138++)
				residences[i138] = (btr138[i138] == 1);
			 
			return retVal;
		}

		public static unsafe void PrioritizeTextures(Int32 n, UInt32[] textures, float[] priorities)
		{
			fixed (float* ptr140 = &priorities[0]) { fixed (UInt32* ptr139 = &textures[0]) { glPrioritizeTextures(n, new IntPtr(ptr139), new IntPtr(ptr140)); }  } 
		}

		public static unsafe void Indexub(byte c)
		{
			glIndexub(c);
		}

		public static unsafe void Indexubv(byte[] c)
		{
			fixed (byte* ptr141 = &c[0]) { glIndexubv(new IntPtr(ptr141)); } 
		}

		public static unsafe void PopClientAttrib()
		{
			glPopClientAttrib();
		}

		public static unsafe void PushClientAttrib(UInt32 mask)
		{
			glPushClientAttrib(mask);
		}

		public static unsafe void BlendColor(float red, float green, float blue, float alpha)
		{
			glBlendColor(red, green, blue, alpha);
		}

		public static unsafe void BlendEquation(GLEnum mode)
		{
			glBlendEquation((uint)mode);
		}

		public static unsafe void DrawRangeElements(BeginMode mode, UInt32 start, UInt32 end, Int32 count, GLEnum type, IntPtr indices)
		{
			glDrawRangeElements((uint)mode, start, end, count, (uint)type, indices);
		}

		public static unsafe void TexImage3D(TextureTarget target, Int32 level, Int32 internalformat, Int32 width, Int32 height, Int32 depth, Int32 border, PixelFormat format, PixelType type, IntPtr pixels)
		{
			glTexImage3D((uint)target, level, internalformat, width, height, depth, border, (uint)format, (uint)type, pixels);
		}

		public static unsafe void TexSubImage3D(TextureTarget target, Int32 level, Int32 xoffset, Int32 yoffset, Int32 zoffset, Int32 width, Int32 height, Int32 depth, PixelFormat format, PixelType type, IntPtr pixels)
		{
			glTexSubImage3D((uint)target, level, xoffset, yoffset, zoffset, width, height, depth, (uint)format, (uint)type, pixels);
		}

		public static unsafe void CopyTexSubImage3D(TextureTarget target, Int32 level, Int32 xoffset, Int32 yoffset, Int32 zoffset, Int32 x, Int32 y, Int32 width, Int32 height)
		{
			glCopyTexSubImage3D((uint)target, level, xoffset, yoffset, zoffset, x, y, width, height);
		}

		public static unsafe void ColorTable(GLEnum target, PixelInternalFormat internalformat, Int32 width, PixelFormat format, PixelType type, IntPtr table)
		{
			glColorTable((uint)target, (uint)internalformat, width, (uint)format, (uint)type, table);
		}

		public static unsafe void ColorTableParameter(GLEnum target, GLEnum pname, float[] parameters)
		{
			fixed (float* ptr142 = &parameters[0]) { glColorTableParameterfv((uint)target, (uint)pname, new IntPtr(ptr142)); } 
		}

		public static unsafe void ColorTableParameter(GLEnum target, GLEnum pname, Int32[] parameters)
		{
			fixed (Int32* ptr143 = &parameters[0]) { glColorTableParameteriv((uint)target, (uint)pname, new IntPtr(ptr143)); } 
		}

		public static unsafe void CopyColorTable(GLEnum target, PixelInternalFormat internalformat, Int32 x, Int32 y, Int32 width)
		{
			glCopyColorTable((uint)target, (uint)internalformat, x, y, width);
		}

		public static unsafe void GetColorTable(GLEnum target, PixelFormat format, PixelType type, [OutAttribute] IntPtr table)
		{
			glGetColorTable((uint)target, (uint)format, (uint)type, table);
		}

		public static unsafe void GetColorTableParameterfv(GLEnum target, GLEnum pname, [OutAttribute] float[] parameters)
		{
			fixed (float* optr144 = parameters) { glGetColorTableParameterfv((uint)target, (uint)pname, optr144); } 
		}

		public static unsafe void GetColorTableParameteriv(GLEnum target, GLEnum pname, [OutAttribute] Int32[] parameters)
		{
			fixed (Int32* optr145 = parameters) { glGetColorTableParameteriv((uint)target, (uint)pname, optr145); } 
		}

		public static unsafe void ColorSubTable(GLEnum target, Int32 start, Int32 count, PixelFormat format, PixelType type, IntPtr data)
		{
			glColorSubTable((uint)target, start, count, (uint)format, (uint)type, data);
		}

		public static unsafe void CopyColorSubTable(GLEnum target, Int32 start, Int32 x, Int32 y, Int32 width)
		{
			glCopyColorSubTable((uint)target, start, x, y, width);
		}

		public static unsafe void ConvolutionFilter1D(GLEnum target, PixelInternalFormat internalformat, Int32 width, PixelFormat format, PixelType type, IntPtr image)
		{
			glConvolutionFilter1D((uint)target, (uint)internalformat, width, (uint)format, (uint)type, image);
		}

		public static unsafe void ConvolutionFilter2D(GLEnum target, PixelInternalFormat internalformat, Int32 width, Int32 height, PixelFormat format, PixelType type, IntPtr image)
		{
			glConvolutionFilter2D((uint)target, (uint)internalformat, width, height, (uint)format, (uint)type, image);
		}

		public static unsafe void ConvolutionParameter(GLEnum target, GLEnum pname, float parameters)
		{
			glConvolutionParameterf((uint)target, (uint)pname, parameters);
		}

		public static unsafe void ConvolutionParameter(GLEnum target, GLEnum pname, float[] parameters)
		{
			fixed (float* ptr146 = &parameters[0]) { glConvolutionParameterfv((uint)target, (uint)pname, new IntPtr(ptr146)); } 
		}

		public static unsafe void ConvolutionParameter(GLEnum target, GLEnum pname, Int32 parameters)
		{
			glConvolutionParameteri((uint)target, (uint)pname, parameters);
		}

		public static unsafe void ConvolutionParameter(GLEnum target, GLEnum pname, Int32[] parameters)
		{
			fixed (Int32* ptr147 = &parameters[0]) { glConvolutionParameteriv((uint)target, (uint)pname, new IntPtr(ptr147)); } 
		}

		public static unsafe void CopyConvolutionFilter1D(GLEnum target, PixelInternalFormat internalformat, Int32 x, Int32 y, Int32 width)
		{
			glCopyConvolutionFilter1D((uint)target, (uint)internalformat, x, y, width);
		}

		public static unsafe void CopyConvolutionFilter2D(GLEnum target, PixelInternalFormat internalformat, Int32 x, Int32 y, Int32 width, Int32 height)
		{
			glCopyConvolutionFilter2D((uint)target, (uint)internalformat, x, y, width, height);
		}

		public static unsafe void GetConvolutionFilter(GLEnum target, PixelFormat format, PixelType type, [OutAttribute] IntPtr image)
		{
			glGetConvolutionFilter((uint)target, (uint)format, (uint)type, image);
		}

		public static unsafe void GetConvolutionParameterfv(GLEnum target, GLEnum pname, [OutAttribute] float[] parameters)
		{
			fixed (float* optr148 = parameters) { glGetConvolutionParameterfv((uint)target, (uint)pname, optr148); } 
		}

		public static unsafe void GetConvolutionParameteriv(GLEnum target, GLEnum pname, [OutAttribute] Int32[] parameters)
		{
			fixed (Int32* optr149 = parameters) { glGetConvolutionParameteriv((uint)target, (uint)pname, optr149); } 
		}

		public static unsafe void GetSeparableFilter(GLEnum target, PixelFormat format, PixelType type, [OutAttribute] IntPtr row, [OutAttribute] IntPtr column, [OutAttribute] IntPtr span)
		{
			glGetSeparableFilter((uint)target, (uint)format, (uint)type, row, column, span);
		}

		public static unsafe void SeparableFilter2D(GLEnum target, PixelInternalFormat internalformat, Int32 width, Int32 height, PixelFormat format, PixelType type, IntPtr row, IntPtr column)
		{
			glSeparableFilter2D((uint)target, (uint)internalformat, width, height, (uint)format, (uint)type, row, column);
		}

		public static unsafe void GetHistogram(GLEnum target, bool reset, PixelFormat format, PixelType type, [OutAttribute] IntPtr values)
		{
			glGetHistogram((uint)target, reset ? ((byte)1) : ((byte)0), (uint)format, (uint)type, values);
		}

		public static unsafe void GetHistogramParameterfv(GLEnum target, GLEnum pname, [OutAttribute] float[] parameters)
		{
			fixed (float* optr150 = parameters) { glGetHistogramParameterfv((uint)target, (uint)pname, optr150); } 
		}

		public static unsafe void GetHistogramParameteriv(GLEnum target, GLEnum pname, [OutAttribute] Int32[] parameters)
		{
			fixed (Int32* optr151 = parameters) { glGetHistogramParameteriv((uint)target, (uint)pname, optr151); } 
		}

		public static unsafe void GetMinmax(GLEnum target, bool reset, PixelFormat format, PixelType type, [OutAttribute] IntPtr values)
		{
			glGetMinmax((uint)target, reset ? ((byte)1) : ((byte)0), (uint)format, (uint)type, values);
		}

		public static unsafe void GetMinmaxParameterfv(GLEnum target, GLEnum pname, [OutAttribute] float[] parameters)
		{
			fixed (float* optr152 = parameters) { glGetMinmaxParameterfv((uint)target, (uint)pname, optr152); } 
		}

		public static unsafe void GetMinmaxParameteriv(GLEnum target, GLEnum pname, [OutAttribute] Int32[] parameters)
		{
			fixed (Int32* optr153 = parameters) { glGetMinmaxParameteriv((uint)target, (uint)pname, optr153); } 
		}

		public static unsafe void Histogram(GLEnum target, Int32 width, PixelInternalFormat internalformat, bool sink)
		{
			glHistogram((uint)target, width, (uint)internalformat, sink ? ((byte)1) : ((byte)0));
		}

		public static unsafe void Minmax(GLEnum target, PixelInternalFormat internalformat, bool sink)
		{
			glMinmax((uint)target, (uint)internalformat, sink ? ((byte)1) : ((byte)0));
		}

		public static unsafe void ResetHistogram(GLEnum target)
		{
			glResetHistogram((uint)target);
		}

		public static unsafe void ResetMinmax(GLEnum target)
		{
			glResetMinmax((uint)target);
		}

		public static unsafe void ActiveTexture(GLEnum texture)
		{
			glActiveTexture((uint)texture);
		}

		public static unsafe void SampleCoverage(float val, bool invert)
		{
			glSampleCoverage(val, invert ? ((byte)1) : ((byte)0));
		}

		public static unsafe void CompressedTexImage3D(TextureTarget target, Int32 level, PixelInternalFormat internalformat, Int32 width, Int32 height, Int32 depth, Int32 border, Int32 imageSize, IntPtr data)
		{
			glCompressedTexImage3D((uint)target, level, (uint)internalformat, width, height, depth, border, imageSize, data);
		}

		public static unsafe void CompressedTexImage2D(TextureTarget target, Int32 level, PixelInternalFormat internalformat, Int32 width, Int32 height, Int32 border, Int32 imageSize, IntPtr data)
		{
			glCompressedTexImage2D((uint)target, level, (uint)internalformat, width, height, border, imageSize, data);
		}

		public static unsafe void CompressedTexImage1D(TextureTarget target, Int32 level, PixelInternalFormat internalformat, Int32 width, Int32 border, Int32 imageSize, IntPtr data)
		{
			glCompressedTexImage1D((uint)target, level, (uint)internalformat, width, border, imageSize, data);
		}

		public static unsafe void CompressedTexSubImage3D(TextureTarget target, Int32 level, Int32 xoffset, Int32 yoffset, Int32 zoffset, Int32 width, Int32 height, Int32 depth, PixelFormat format, Int32 imageSize, IntPtr data)
		{
			glCompressedTexSubImage3D((uint)target, level, xoffset, yoffset, zoffset, width, height, depth, (uint)format, imageSize, data);
		}

		public static unsafe void CompressedTexSubImage2D(TextureTarget target, Int32 level, Int32 xoffset, Int32 yoffset, Int32 width, Int32 height, PixelFormat format, Int32 imageSize, IntPtr data)
		{
			glCompressedTexSubImage2D((uint)target, level, xoffset, yoffset, width, height, (uint)format, imageSize, data);
		}

		public static unsafe void CompressedTexSubImage1D(TextureTarget target, Int32 level, Int32 xoffset, Int32 width, PixelFormat format, Int32 imageSize, IntPtr data)
		{
			glCompressedTexSubImage1D((uint)target, level, xoffset, width, (uint)format, imageSize, data);
		}

		public static unsafe void GetCompressedTexImage(TextureTarget target, Int32 level, [OutAttribute] IntPtr img)
		{
			glGetCompressedTexImage((uint)target, level, img);
		}

		public static unsafe void ClientActiveTexture(GLEnum texture)
		{
			glClientActiveTexture((uint)texture);
		}

		public static unsafe void MultiTexCoord1(GLEnum target, double s)
		{
			glMultiTexCoord1d((uint)target, s);
		}

		public static unsafe void MultiTexCoord1(GLEnum target, double[] v)
		{
			fixed (double* ptr154 = &v[0]) { glMultiTexCoord1dv((uint)target, new IntPtr(ptr154)); } 
		}

		public static unsafe void MultiTexCoord1(GLEnum target, float s)
		{
			glMultiTexCoord1f((uint)target, s);
		}

		public static unsafe void MultiTexCoord1(GLEnum target, float[] v)
		{
			fixed (float* ptr155 = &v[0]) { glMultiTexCoord1fv((uint)target, new IntPtr(ptr155)); } 
		}

		public static unsafe void MultiTexCoord1(GLEnum target, Int32 s)
		{
			glMultiTexCoord1i((uint)target, s);
		}

		public static unsafe void MultiTexCoord1(GLEnum target, Int32[] v)
		{
			fixed (Int32* ptr156 = &v[0]) { glMultiTexCoord1iv((uint)target, new IntPtr(ptr156)); } 
		}

		public static unsafe void MultiTexCoord1(GLEnum target, Int16 s)
		{
			glMultiTexCoord1s((uint)target, s);
		}

		public static unsafe void MultiTexCoord1(GLEnum target, Int16[] v)
		{
			fixed (Int16* ptr157 = &v[0]) { glMultiTexCoord1sv((uint)target, new IntPtr(ptr157)); } 
		}

		public static unsafe void MultiTexCoord2(GLEnum target, double s, double t)
		{
			glMultiTexCoord2d((uint)target, s, t);
		}

		public static unsafe void MultiTexCoord2(GLEnum target, double[] v)
		{
			fixed (double* ptr158 = &v[0]) { glMultiTexCoord2dv((uint)target, new IntPtr(ptr158)); } 
		}

		public static unsafe void MultiTexCoord2(GLEnum target, float s, float t)
		{
			glMultiTexCoord2f((uint)target, s, t);
		}

		public static unsafe void MultiTexCoord2(GLEnum target, float[] v)
		{
			fixed (float* ptr159 = &v[0]) { glMultiTexCoord2fv((uint)target, new IntPtr(ptr159)); } 
		}

		public static unsafe void MultiTexCoord2(GLEnum target, Int32 s, Int32 t)
		{
			glMultiTexCoord2i((uint)target, s, t);
		}

		public static unsafe void MultiTexCoord2(GLEnum target, Int32[] v)
		{
			fixed (Int32* ptr160 = &v[0]) { glMultiTexCoord2iv((uint)target, new IntPtr(ptr160)); } 
		}

		public static unsafe void MultiTexCoord2(GLEnum target, Int16 s, Int16 t)
		{
			glMultiTexCoord2s((uint)target, s, t);
		}

		public static unsafe void MultiTexCoord2(GLEnum target, Int16[] v)
		{
			fixed (Int16* ptr161 = &v[0]) { glMultiTexCoord2sv((uint)target, new IntPtr(ptr161)); } 
		}

		public static unsafe void MultiTexCoord3(GLEnum target, double s, double t, double r)
		{
			glMultiTexCoord3d((uint)target, s, t, r);
		}

		public static unsafe void MultiTexCoord3(GLEnum target, double[] v)
		{
			fixed (double* ptr162 = &v[0]) { glMultiTexCoord3dv((uint)target, new IntPtr(ptr162)); } 
		}

		public static unsafe void MultiTexCoord3(GLEnum target, float s, float t, float r)
		{
			glMultiTexCoord3f((uint)target, s, t, r);
		}

		public static unsafe void MultiTexCoord3(GLEnum target, float[] v)
		{
			fixed (float* ptr163 = &v[0]) { glMultiTexCoord3fv((uint)target, new IntPtr(ptr163)); } 
		}

		public static unsafe void MultiTexCoord3(GLEnum target, Int32 s, Int32 t, Int32 r)
		{
			glMultiTexCoord3i((uint)target, s, t, r);
		}

		public static unsafe void MultiTexCoord3(GLEnum target, Int32[] v)
		{
			fixed (Int32* ptr164 = &v[0]) { glMultiTexCoord3iv((uint)target, new IntPtr(ptr164)); } 
		}

		public static unsafe void MultiTexCoord3(GLEnum target, Int16 s, Int16 t, Int16 r)
		{
			glMultiTexCoord3s((uint)target, s, t, r);
		}

		public static unsafe void MultiTexCoord3(GLEnum target, Int16[] v)
		{
			fixed (Int16* ptr165 = &v[0]) { glMultiTexCoord3sv((uint)target, new IntPtr(ptr165)); } 
		}

		public static unsafe void MultiTexCoord4(GLEnum target, double s, double t, double r, double q)
		{
			glMultiTexCoord4d((uint)target, s, t, r, q);
		}

		public static unsafe void MultiTexCoord4(GLEnum target, double[] v)
		{
			fixed (double* ptr166 = &v[0]) { glMultiTexCoord4dv((uint)target, new IntPtr(ptr166)); } 
		}

		public static unsafe void MultiTexCoord4(GLEnum target, float s, float t, float r, float q)
		{
			glMultiTexCoord4f((uint)target, s, t, r, q);
		}

		public static unsafe void MultiTexCoord4(GLEnum target, float[] v)
		{
			fixed (float* ptr167 = &v[0]) { glMultiTexCoord4fv((uint)target, new IntPtr(ptr167)); } 
		}

		public static unsafe void MultiTexCoord4(GLEnum target, Int32 s, Int32 t, Int32 r, Int32 q)
		{
			glMultiTexCoord4i((uint)target, s, t, r, q);
		}

		public static unsafe void MultiTexCoord4(GLEnum target, Int32[] v)
		{
			fixed (Int32* ptr168 = &v[0]) { glMultiTexCoord4iv((uint)target, new IntPtr(ptr168)); } 
		}

		public static unsafe void MultiTexCoord4(GLEnum target, Int16 s, Int16 t, Int16 r, Int16 q)
		{
			glMultiTexCoord4s((uint)target, s, t, r, q);
		}

		public static unsafe void MultiTexCoord4(GLEnum target, Int16[] v)
		{
			fixed (Int16* ptr169 = &v[0]) { glMultiTexCoord4sv((uint)target, new IntPtr(ptr169)); } 
		}

		public static unsafe void LoadTransposeMatrix(float[] m)
		{
			fixed (float* ptr170 = &m[0]) { glLoadTransposeMatrixf(new IntPtr(ptr170)); } 
		}

		public static unsafe void LoadTransposeMatrix(double[] m)
		{
			fixed (double* ptr171 = &m[0]) { glLoadTransposeMatrixd(new IntPtr(ptr171)); } 
		}

		public static unsafe void MultTransposeMatrix(float[] m)
		{
			fixed (float* ptr172 = &m[0]) { glMultTransposeMatrixf(new IntPtr(ptr172)); } 
		}

		public static unsafe void MultTransposeMatrix(double[] m)
		{
			fixed (double* ptr173 = &m[0]) { glMultTransposeMatrixd(new IntPtr(ptr173)); } 
		}

		public static unsafe void BlendFuncSeparate(GLEnum sfactorRGB, GLEnum dfactorRGB, GLEnum sfactorAlpha, GLEnum dfactorAlpha)
		{
			glBlendFuncSeparate((uint)sfactorRGB, (uint)dfactorRGB, (uint)sfactorAlpha, (uint)dfactorAlpha);
		}

		public static unsafe void MultiDrawArrays(BeginMode mode, [OutAttribute] Int32[] first, [OutAttribute] Int32[] count, Int32 primcount)
		{
			fixed (Int32* optr175 = count) { fixed (Int32* optr174 = first) { glMultiDrawArrays((uint)mode, optr174, optr175, primcount); }  } 
		}

		public static unsafe void MultiDrawElements(BeginMode mode, Int32[] count, GLEnum type, IntPtr[] indices, Int32 primcount)
		{
			fixed (IntPtr* ptr177 = &indices[0]) { fixed (Int32* ptr176 = &count[0]) { glMultiDrawElements((uint)mode, new IntPtr(ptr176), (uint)type, new IntPtr(ptr177), primcount); }  } 
		}

		public static unsafe void PointParameter(GLEnum pname, float param)
		{
			glPointParameterf((uint)pname, param);
		}

		public static unsafe void PointParameter(GLEnum pname, float[] parameters)
		{
			fixed (float* ptr178 = &parameters[0]) { glPointParameterfv((uint)pname, new IntPtr(ptr178)); } 
		}

		public static unsafe void PointParameter(GLEnum pname, Int32 param)
		{
			glPointParameteri((uint)pname, param);
		}

		public static unsafe void PointParameter(GLEnum pname, Int32[] parameters)
		{
			fixed (Int32* ptr179 = &parameters[0]) { glPointParameteriv((uint)pname, new IntPtr(ptr179)); } 
		}

		public static unsafe void FogCoord(float coord)
		{
			glFogCoordf(coord);
		}

		public static unsafe void FogCoord(float[] coord)
		{
			fixed (float* ptr180 = &coord[0]) { glFogCoordfv(new IntPtr(ptr180)); } 
		}

		public static unsafe void FogCoord(double coord)
		{
			glFogCoordd(coord);
		}

		public static unsafe void FogCoord(double[] coord)
		{
			fixed (double* ptr181 = &coord[0]) { glFogCoorddv(new IntPtr(ptr181)); } 
		}

		public static unsafe void FogCoordPointer(GLEnum type, Int32 stride, IntPtr pointer)
		{
			glFogCoordPointer((uint)type, stride, pointer);
		}

		public static unsafe void SecondaryColor3(SByte red, SByte green, SByte blue)
		{
			glSecondaryColor3b(red, green, blue);
		}

		public static unsafe void SecondaryColor3(SByte[] v)
		{
			fixed (SByte* ptr182 = &v[0]) { glSecondaryColor3bv(new IntPtr(ptr182)); } 
		}

		public static unsafe void SecondaryColor3(double red, double green, double blue)
		{
			glSecondaryColor3d(red, green, blue);
		}

		public static unsafe void SecondaryColor3(double[] v)
		{
			fixed (double* ptr183 = &v[0]) { glSecondaryColor3dv(new IntPtr(ptr183)); } 
		}

		public static unsafe void SecondaryColor3(float red, float green, float blue)
		{
			glSecondaryColor3f(red, green, blue);
		}

		public static unsafe void SecondaryColor3(float[] v)
		{
			fixed (float* ptr184 = &v[0]) { glSecondaryColor3fv(new IntPtr(ptr184)); } 
		}

		public static unsafe void SecondaryColor3(Int32 red, Int32 green, Int32 blue)
		{
			glSecondaryColor3i(red, green, blue);
		}

		public static unsafe void SecondaryColor3(Int32[] v)
		{
			fixed (Int32* ptr185 = &v[0]) { glSecondaryColor3iv(new IntPtr(ptr185)); } 
		}

		public static unsafe void SecondaryColor3(Int16 red, Int16 green, Int16 blue)
		{
			glSecondaryColor3s(red, green, blue);
		}

		public static unsafe void SecondaryColor3(Int16[] v)
		{
			fixed (Int16* ptr186 = &v[0]) { glSecondaryColor3sv(new IntPtr(ptr186)); } 
		}

		public static unsafe void SecondaryColor3(byte red, byte green, byte blue)
		{
			glSecondaryColor3ub(red, green, blue);
		}

		public static unsafe void SecondaryColor3(byte[] v)
		{
			fixed (byte* ptr187 = &v[0]) { glSecondaryColor3ubv(new IntPtr(ptr187)); } 
		}

		public static unsafe void SecondaryColor3(UInt32 red, UInt32 green, UInt32 blue)
		{
			glSecondaryColor3ui(red, green, blue);
		}

		public static unsafe void SecondaryColor3(UInt32[] v)
		{
			fixed (UInt32* ptr188 = &v[0]) { glSecondaryColor3uiv(new IntPtr(ptr188)); } 
		}

		public static unsafe void SecondaryColor3(UInt16 red, UInt16 green, UInt16 blue)
		{
			glSecondaryColor3us(red, green, blue);
		}

		public static unsafe void SecondaryColor3(UInt16[] v)
		{
			fixed (UInt16* ptr189 = &v[0]) { glSecondaryColor3usv(new IntPtr(ptr189)); } 
		}

		public static unsafe void SecondaryColorPointer(Int32 size, ColorPointerType type, Int32 stride, IntPtr pointer)
		{
			glSecondaryColorPointer(size, (uint)type, stride, pointer);
		}

		public static unsafe void WindowPos2(double x, double y)
		{
			glWindowPos2d(x, y);
		}

		public static unsafe void WindowPos2(double[] v)
		{
			fixed (double* ptr190 = &v[0]) { glWindowPos2dv(new IntPtr(ptr190)); } 
		}

		public static unsafe void WindowPos2(float x, float y)
		{
			glWindowPos2f(x, y);
		}

		public static unsafe void WindowPos2(float[] v)
		{
			fixed (float* ptr191 = &v[0]) { glWindowPos2fv(new IntPtr(ptr191)); } 
		}

		public static unsafe void WindowPos2(Int32 x, Int32 y)
		{
			glWindowPos2i(x, y);
		}

		public static unsafe void WindowPos2(Int32[] v)
		{
			fixed (Int32* ptr192 = &v[0]) { glWindowPos2iv(new IntPtr(ptr192)); } 
		}

		public static unsafe void WindowPos2(Int16 x, Int16 y)
		{
			glWindowPos2s(x, y);
		}

		public static unsafe void WindowPos2(Int16[] v)
		{
			fixed (Int16* ptr193 = &v[0]) { glWindowPos2sv(new IntPtr(ptr193)); } 
		}

		public static unsafe void WindowPos3(double x, double y, double z)
		{
			glWindowPos3d(x, y, z);
		}

		public static unsafe void WindowPos3(double[] v)
		{
			fixed (double* ptr194 = &v[0]) { glWindowPos3dv(new IntPtr(ptr194)); } 
		}

		public static unsafe void WindowPos3(float x, float y, float z)
		{
			glWindowPos3f(x, y, z);
		}

		public static unsafe void WindowPos3(float[] v)
		{
			fixed (float* ptr195 = &v[0]) { glWindowPos3fv(new IntPtr(ptr195)); } 
		}

		public static unsafe void WindowPos3(Int32 x, Int32 y, Int32 z)
		{
			glWindowPos3i(x, y, z);
		}

		public static unsafe void WindowPos3(Int32[] v)
		{
			fixed (Int32* ptr196 = &v[0]) { glWindowPos3iv(new IntPtr(ptr196)); } 
		}

		public static unsafe void WindowPos3(Int16 x, Int16 y, Int16 z)
		{
			glWindowPos3s(x, y, z);
		}

		public static unsafe void WindowPos3(Int16[] v)
		{
			fixed (Int16* ptr197 = &v[0]) { glWindowPos3sv(new IntPtr(ptr197)); } 
		}

		public static unsafe void GenQueries(Int32 n, [OutAttribute] UInt32[] ids)
		{
			fixed (UInt32* optr198 = ids) { glGenQueries(n, optr198); } 
		}

		public static unsafe void DeleteQueries(Int32 n, UInt32[] ids)
		{
			fixed (UInt32* ptr199 = &ids[0]) { glDeleteQueries(n, new IntPtr(ptr199)); } 
		}

		public static unsafe bool IsQuery(UInt32 id)
		{
			return (glIsQuery(id) == 1);
		}

		public static unsafe void BeginQuery(GLEnum target, UInt32 id)
		{
			glBeginQuery((uint)target, id);
		}

		public static unsafe void EndQuery(GLEnum target)
		{
			glEndQuery((uint)target);
		}

		public static unsafe void GetQueryiv(GLEnum target, GLEnum pname, [OutAttribute] Int32[] parameters)
		{
			fixed (Int32* optr200 = parameters) { glGetQueryiv((uint)target, (uint)pname, optr200); } 
		}

		public static unsafe void GetQueryObjectiv(UInt32 id, GLEnum pname, [OutAttribute] Int32[] parameters)
		{
			fixed (Int32* optr201 = parameters) { glGetQueryObjectiv(id, (uint)pname, optr201); } 
		}

		public static unsafe void GetQueryObjectuiv(UInt32 id, GLEnum pname, [OutAttribute] UInt32[] parameters)
		{
			fixed (UInt32* optr202 = parameters) { glGetQueryObjectuiv(id, (uint)pname, optr202); } 
		}

		public static unsafe void BindBuffer(GLEnum target, UInt32 buffer)
		{
			glBindBuffer((uint)target, buffer);
		}

		public static unsafe void DeleteBuffers(Int32 n, UInt32[] buffers)
		{
			fixed (UInt32* ptr203 = &buffers[0]) { glDeleteBuffers(n, new IntPtr(ptr203)); } 
		}

		public static unsafe void GenBuffers(Int32 n, [OutAttribute] UInt32[] buffers)
		{
			fixed (UInt32* optr204 = buffers) { glGenBuffers(n, optr204); } 
		}

		public static unsafe bool IsBuffer(UInt32 buffer)
		{
			return (glIsBuffer(buffer) == 1);
		}

		public static unsafe void BufferData(GLEnum target, IntPtr size, IntPtr data, GLEnum usage)
		{
			glBufferData((uint)target, size, data, (uint)usage);
		}

		public static unsafe void BufferSubData(GLEnum target, IntPtr offset, IntPtr size, IntPtr data)
		{
			glBufferSubData((uint)target, offset, size, data);
		}

		public static unsafe void GetBufferSubData(GLEnum target, IntPtr offset, IntPtr size, [OutAttribute] IntPtr data)
		{
			glGetBufferSubData((uint)target, offset, size, data);
		}

		public static unsafe IntPtr MapBuffer(GLEnum target, GLEnum access)
		{
			return glMapBuffer((uint)target, (uint)access);
		}

		public static unsafe bool UnmapBuffer(GLEnum target)
		{
			return (glUnmapBuffer((uint)target) == 1);
		}

		public static unsafe void GetBufferParameteriv(GLEnum target, GLEnum pname, [OutAttribute] Int32[] parameters)
		{
			fixed (Int32* optr205 = parameters) { glGetBufferParameteriv((uint)target, (uint)pname, optr205); } 
		}

		public static unsafe void GetBufferPointerv(GLEnum target, GLEnum pname, [OutAttribute] IntPtr[] parameters)
		{
			fixed (IntPtr* optr206 = parameters) { glGetBufferPointerv((uint)target, (uint)pname, optr206); } 
		}

		public static unsafe void BlendEquationSeparate(BlendEquationModeEXT modeRGB, BlendEquationModeEXT modeAlpha)
		{
			glBlendEquationSeparate((uint)modeRGB, (uint)modeAlpha);
		}

		public static unsafe void DrawBuffers(Int32 n, GLEnum[] bufs)
		{
			fixed (GLEnum* ptr207 = &bufs[0]) { glDrawBuffers(n, new IntPtr(ptr207)); } 
		}

		public static unsafe void StencilOpSeparate(GLEnum face, StencilOp sfail, StencilOp dpfail, StencilOp dppass)
		{
			glStencilOpSeparate((uint)face, (uint)sfail, (uint)dpfail, (uint)dppass);
		}

		public static unsafe void StencilFuncSeparate(StencilFunction frontfunc, StencilFunction backfunc, Int32 reference, UInt32 mask)
		{
			glStencilFuncSeparate((uint)frontfunc, (uint)backfunc, reference, mask);
		}

		public static unsafe void StencilMaskSeparate(GLEnum face, UInt32 mask)
		{
			glStencilMaskSeparate((uint)face, mask);
		}

		public static unsafe void AttachShader(UInt32 program, UInt32 shader)
		{
			glAttachShader(program, shader);
		}

		public static unsafe void BindAttribLocation(UInt32 program, UInt32 index, byte[] name)
		{
			fixed (byte* ptr208 = &name[0]) { glBindAttribLocation(program, index, new IntPtr(ptr208)); } 
		}

		public static unsafe void CompileShader(UInt32 shader)
		{
			glCompileShader(shader);
		}

		public static unsafe UInt32 CreateProgram()
		{
			return glCreateProgram();
		}

		public static unsafe UInt32 CreateShader(GLEnum type)
		{
			return glCreateShader((uint)type);
		}

		public static unsafe void DeleteProgram(UInt32 program)
		{
			glDeleteProgram(program);
		}

		public static unsafe void DeleteShader(UInt32 shader)
		{
			glDeleteShader(shader);
		}

		public static unsafe void DetachShader(UInt32 program, UInt32 shader)
		{
			glDetachShader(program, shader);
		}

		public static unsafe void DisableVertexAttribArray(UInt32 index)
		{
			glDisableVertexAttribArray(index);
		}

		public static unsafe void EnableVertexAttribArray(UInt32 index)
		{
			glEnableVertexAttribArray(index);
		}

		public static unsafe void GetActiveAttrib(UInt32 program, UInt32 index, Int32 bufSize, [OutAttribute] Int32[] length, [OutAttribute] Int32[] size, [OutAttribute] GLEnum[] type, [OutAttribute] byte[] name)
		{
			fixed (byte* optr212 = name) { uint[] unt211 = new uint[type.Length];
			fixed (uint* ptr211 = unt211) { fixed (Int32* optr210 = size) { fixed (Int32* optr209 = length) { glGetActiveAttrib(program, index, bufSize, optr209, optr210, ptr211, optr212); }  }  } 
			for (int i = 0; i < unt211.Length; i++)
				type[i] = (GLEnum)unt211[i];
			 } 
		}

		public static unsafe void GetActiveUniform(UInt32 program, UInt32 index, Int32 bufSize, [OutAttribute] Int32[] length, [OutAttribute] Int32[] size, [OutAttribute] GLEnum[] type, [OutAttribute] byte[] name)
		{
			fixed (byte* optr216 = name) { uint[] unt215 = new uint[type.Length];
			fixed (uint* ptr215 = unt215) { fixed (Int32* optr214 = size) { fixed (Int32* optr213 = length) { glGetActiveUniform(program, index, bufSize, optr213, optr214, ptr215, optr216); }  }  } 
			for (int i = 0; i < unt215.Length; i++)
				type[i] = (GLEnum)unt215[i];
			 } 
		}

		public static unsafe void GetAttachedShaders(UInt32 program, Int32 maxCount, [OutAttribute] Int32[] count, [OutAttribute] UInt32[] obj)
		{
			fixed (UInt32* optr218 = obj) { fixed (Int32* optr217 = count) { glGetAttachedShaders(program, maxCount, optr217, optr218); }  } 
		}

		public static unsafe Int32 GetAttribLocation(UInt32 program, byte[] name)
		{
			fixed (byte* ptr219 = &name[0]) { return glGetAttribLocation(program, new IntPtr(ptr219)); } 
		}

		public static unsafe void GetProgramiv(UInt32 program, GLEnum pname, [OutAttribute] Int32[] parameters)
		{
			fixed (Int32* optr220 = parameters) { glGetProgramiv(program, (uint)pname, optr220); } 
		}

		public static unsafe void GetProgramInfoLog(UInt32 program, Int32 bufSize, [OutAttribute] Int32[] length, [OutAttribute] byte[] infoLog)
		{
			fixed (byte* optr222 = infoLog) { fixed (Int32* optr221 = length) { glGetProgramInfoLog(program, bufSize, optr221, optr222); }  } 
		}

		public static unsafe void GetShaderiv(UInt32 shader, GLEnum pname, [OutAttribute] Int32[] parameters)
		{
			fixed (Int32* optr223 = parameters) { glGetShaderiv(shader, (uint)pname, optr223); } 
		}

		public static unsafe void GetShaderInfoLog(UInt32 shader, Int32 bufSize, [OutAttribute] Int32[] length, [OutAttribute] byte[] infoLog)
		{
			fixed (byte* optr225 = infoLog) { fixed (Int32* optr224 = length) { glGetShaderInfoLog(shader, bufSize, optr224, optr225); }  } 
		}

		public static unsafe void GetShaderSource(UInt32 shader, Int32 bufSize, [OutAttribute] Int32[] length, [OutAttribute] byte[] source)
		{
			fixed (byte* optr227 = source) { fixed (Int32* optr226 = length) { glGetShaderSource(shader, bufSize, optr226, optr227); }  } 
		}

		public static unsafe Int32 GetUniformLocation(UInt32 program, byte[] name)
		{
			fixed (byte* ptr228 = &name[0]) { return glGetUniformLocation(program, new IntPtr(ptr228)); } 
		}

		public static unsafe void GetUniformfv(UInt32 program, Int32 location, [OutAttribute] float[] parameters)
		{
			fixed (float* optr229 = parameters) { glGetUniformfv(program, location, optr229); } 
		}

		public static unsafe void GetUniformiv(UInt32 program, Int32 location, [OutAttribute] Int32[] parameters)
		{
			fixed (Int32* optr230 = parameters) { glGetUniformiv(program, location, optr230); } 
		}

		public static unsafe void GetVertexAttribdv(UInt32 index, GLEnum pname, [OutAttribute] double[] parameters)
		{
			fixed (double* optr231 = parameters) { glGetVertexAttribdv(index, (uint)pname, optr231); } 
		}

		public static unsafe void GetVertexAttribfv(UInt32 index, GLEnum pname, [OutAttribute] float[] parameters)
		{
			fixed (float* optr232 = parameters) { glGetVertexAttribfv(index, (uint)pname, optr232); } 
		}

		public static unsafe void GetVertexAttribiv(UInt32 index, GLEnum pname, [OutAttribute] Int32[] parameters)
		{
			fixed (Int32* optr233 = parameters) { glGetVertexAttribiv(index, (uint)pname, optr233); } 
		}

		public static unsafe void GetVertexAttribPointerv(UInt32 index, GLEnum pname, [OutAttribute] IntPtr[] pointer)
		{
			fixed (IntPtr* optr234 = pointer) { glGetVertexAttribPointerv(index, (uint)pname, optr234); } 
		}

		public static unsafe bool IsProgram(UInt32 program)
		{
			return (glIsProgram(program) == 1);
		}

		public static unsafe bool IsShader(UInt32 shader)
		{
			return (glIsShader(shader) == 1);
		}

		public static unsafe void LinkProgram(UInt32 program)
		{
			glLinkProgram(program);
		}

		public static unsafe void ShaderSource(UInt32 shader, Int32 count, IntPtr[] str, Int32[] length)
		{
			fixed (Int32* ptr236 = &length[0]) { fixed (IntPtr* ptr235 = &str[0]) { glShaderSource(shader, count, new IntPtr(ptr235), new IntPtr(ptr236)); }  } 
		}

		public static unsafe void UseProgram(UInt32 program)
		{
			glUseProgram(program);
		}

		public static unsafe void Uniform1(Int32 location, float v0)
		{
			glUniform1f(location, v0);
		}

		public static unsafe void Uniform2(Int32 location, float v0, float v1)
		{
			glUniform2f(location, v0, v1);
		}

		public static unsafe void Uniform3(Int32 location, float v0, float v1, float v2)
		{
			glUniform3f(location, v0, v1, v2);
		}

		public static unsafe void Uniform4(Int32 location, float v0, float v1, float v2, float v3)
		{
			glUniform4f(location, v0, v1, v2, v3);
		}

		public static unsafe void Uniform1(Int32 location, Int32 v0)
		{
			glUniform1i(location, v0);
		}

		public static unsafe void Uniform2(Int32 location, Int32 v0, Int32 v1)
		{
			glUniform2i(location, v0, v1);
		}

		public static unsafe void Uniform3(Int32 location, Int32 v0, Int32 v1, Int32 v2)
		{
			glUniform3i(location, v0, v1, v2);
		}

		public static unsafe void Uniform4(Int32 location, Int32 v0, Int32 v1, Int32 v2, Int32 v3)
		{
			glUniform4i(location, v0, v1, v2, v3);
		}

		public static unsafe void Uniform1(Int32 location, Int32 count, float[] val)
		{
			fixed (float* ptr237 = &val[0]) { glUniform1fv(location, count, new IntPtr(ptr237)); } 
		}

		public static unsafe void Uniform2(Int32 location, Int32 count, float[] val)
		{
			fixed (float* ptr238 = &val[0]) { glUniform2fv(location, count, new IntPtr(ptr238)); } 
		}

		public static unsafe void Uniform3(Int32 location, Int32 count, float[] val)
		{
			fixed (float* ptr239 = &val[0]) { glUniform3fv(location, count, new IntPtr(ptr239)); } 
		}

		public static unsafe void Uniform4(Int32 location, Int32 count, float[] val)
		{
			fixed (float* ptr240 = &val[0]) { glUniform4fv(location, count, new IntPtr(ptr240)); } 
		}

		public static unsafe void Uniform1(Int32 location, Int32 count, Int32[] val)
		{
			fixed (Int32* ptr241 = &val[0]) { glUniform1iv(location, count, new IntPtr(ptr241)); } 
		}

		public static unsafe void Uniform2(Int32 location, Int32 count, Int32[] val)
		{
			fixed (Int32* ptr242 = &val[0]) { glUniform2iv(location, count, new IntPtr(ptr242)); } 
		}

		public static unsafe void Uniform3(Int32 location, Int32 count, Int32[] val)
		{
			fixed (Int32* ptr243 = &val[0]) { glUniform3iv(location, count, new IntPtr(ptr243)); } 
		}

		public static unsafe void Uniform4(Int32 location, Int32 count, Int32[] val)
		{
			fixed (Int32* ptr244 = &val[0]) { glUniform4iv(location, count, new IntPtr(ptr244)); } 
		}

		public static unsafe void UniformMatrix2(Int32 location, Int32 count, bool transpose, float[] val)
		{
			fixed (float* ptr245 = &val[0]) { glUniformMatrix2fv(location, count, transpose ? ((byte)1) : ((byte)0), new IntPtr(ptr245)); } 
		}

		public static unsafe void UniformMatrix3(Int32 location, Int32 count, bool transpose, float[] val)
		{
			fixed (float* ptr246 = &val[0]) { glUniformMatrix3fv(location, count, transpose ? ((byte)1) : ((byte)0), new IntPtr(ptr246)); } 
		}

		public static unsafe void UniformMatrix4(Int32 location, Int32 count, bool transpose, float[] val)
		{
			fixed (float* ptr247 = &val[0]) { glUniformMatrix4fv(location, count, transpose ? ((byte)1) : ((byte)0), new IntPtr(ptr247)); } 
		}

		public static unsafe void ValidateProgram(UInt32 program)
		{
			glValidateProgram(program);
		}

		public static unsafe void VertexAttrib1(UInt32 index, double x)
		{
			glVertexAttrib1d(index, x);
		}

		public static unsafe void VertexAttrib1(UInt32 index, double[] v)
		{
			fixed (double* ptr248 = &v[0]) { glVertexAttrib1dv(index, new IntPtr(ptr248)); } 
		}

		public static unsafe void VertexAttrib1(UInt32 index, float x)
		{
			glVertexAttrib1f(index, x);
		}

		public static unsafe void VertexAttrib1(UInt32 index, float[] v)
		{
			fixed (float* ptr249 = &v[0]) { glVertexAttrib1fv(index, new IntPtr(ptr249)); } 
		}

		public static unsafe void VertexAttrib1(UInt32 index, Int16 x)
		{
			glVertexAttrib1s(index, x);
		}

		public static unsafe void VertexAttrib1(UInt32 index, Int16[] v)
		{
			fixed (Int16* ptr250 = &v[0]) { glVertexAttrib1sv(index, new IntPtr(ptr250)); } 
		}

		public static unsafe void VertexAttrib2(UInt32 index, double x, double y)
		{
			glVertexAttrib2d(index, x, y);
		}

		public static unsafe void VertexAttrib2(UInt32 index, double[] v)
		{
			fixed (double* ptr251 = &v[0]) { glVertexAttrib2dv(index, new IntPtr(ptr251)); } 
		}

		public static unsafe void VertexAttrib2(UInt32 index, float x, float y)
		{
			glVertexAttrib2f(index, x, y);
		}

		public static unsafe void VertexAttrib2(UInt32 index, float[] v)
		{
			fixed (float* ptr252 = &v[0]) { glVertexAttrib2fv(index, new IntPtr(ptr252)); } 
		}

		public static unsafe void VertexAttrib2(UInt32 index, Int16 x, Int16 y)
		{
			glVertexAttrib2s(index, x, y);
		}

		public static unsafe void VertexAttrib2(UInt32 index, Int16[] v)
		{
			fixed (Int16* ptr253 = &v[0]) { glVertexAttrib2sv(index, new IntPtr(ptr253)); } 
		}

		public static unsafe void VertexAttrib3(UInt32 index, double x, double y, double z)
		{
			glVertexAttrib3d(index, x, y, z);
		}

		public static unsafe void VertexAttrib3(UInt32 index, double[] v)
		{
			fixed (double* ptr254 = &v[0]) { glVertexAttrib3dv(index, new IntPtr(ptr254)); } 
		}

		public static unsafe void VertexAttrib3(UInt32 index, float x, float y, float z)
		{
			glVertexAttrib3f(index, x, y, z);
		}

		public static unsafe void VertexAttrib3(UInt32 index, float[] v)
		{
			fixed (float* ptr255 = &v[0]) { glVertexAttrib3fv(index, new IntPtr(ptr255)); } 
		}

		public static unsafe void VertexAttrib3(UInt32 index, Int16 x, Int16 y, Int16 z)
		{
			glVertexAttrib3s(index, x, y, z);
		}

		public static unsafe void VertexAttrib3(UInt32 index, Int16[] v)
		{
			fixed (Int16* ptr256 = &v[0]) { glVertexAttrib3sv(index, new IntPtr(ptr256)); } 
		}

		public static unsafe void VertexAttrib4N(UInt32 index, SByte[] v)
		{
			fixed (SByte* ptr257 = &v[0]) { glVertexAttrib4Nbv(index, new IntPtr(ptr257)); } 
		}

		public static unsafe void VertexAttrib4N(UInt32 index, Int32[] v)
		{
			fixed (Int32* ptr258 = &v[0]) { glVertexAttrib4Niv(index, new IntPtr(ptr258)); } 
		}

		public static unsafe void VertexAttrib4N(UInt32 index, Int16[] v)
		{
			fixed (Int16* ptr259 = &v[0]) { glVertexAttrib4Nsv(index, new IntPtr(ptr259)); } 
		}

		public static unsafe void VertexAttrib4N(UInt32 index, byte x, byte y, byte z, byte w)
		{
			glVertexAttrib4Nub(index, x, y, z, w);
		}

		public static unsafe void VertexAttrib4N(UInt32 index, byte[] v)
		{
			fixed (byte* ptr260 = &v[0]) { glVertexAttrib4Nubv(index, new IntPtr(ptr260)); } 
		}

		public static unsafe void VertexAttrib4N(UInt32 index, UInt32[] v)
		{
			fixed (UInt32* ptr261 = &v[0]) { glVertexAttrib4Nuiv(index, new IntPtr(ptr261)); } 
		}

		public static unsafe void VertexAttrib4N(UInt32 index, UInt16[] v)
		{
			fixed (UInt16* ptr262 = &v[0]) { glVertexAttrib4Nusv(index, new IntPtr(ptr262)); } 
		}

		public static unsafe void VertexAttrib4(UInt32 index, SByte[] v)
		{
			fixed (SByte* ptr263 = &v[0]) { glVertexAttrib4bv(index, new IntPtr(ptr263)); } 
		}

		public static unsafe void VertexAttrib4(UInt32 index, double x, double y, double z, double w)
		{
			glVertexAttrib4d(index, x, y, z, w);
		}

		public static unsafe void VertexAttrib4(UInt32 index, double[] v)
		{
			fixed (double* ptr264 = &v[0]) { glVertexAttrib4dv(index, new IntPtr(ptr264)); } 
		}

		public static unsafe void VertexAttrib4(UInt32 index, float x, float y, float z, float w)
		{
			glVertexAttrib4f(index, x, y, z, w);
		}

		public static unsafe void VertexAttrib4(UInt32 index, float[] v)
		{
			fixed (float* ptr265 = &v[0]) { glVertexAttrib4fv(index, new IntPtr(ptr265)); } 
		}

		public static unsafe void VertexAttrib4(UInt32 index, Int32[] v)
		{
			fixed (Int32* ptr266 = &v[0]) { glVertexAttrib4iv(index, new IntPtr(ptr266)); } 
		}

		public static unsafe void VertexAttrib4(UInt32 index, Int16 x, Int16 y, Int16 z, Int16 w)
		{
			glVertexAttrib4s(index, x, y, z, w);
		}

		public static unsafe void VertexAttrib4(UInt32 index, Int16[] v)
		{
			fixed (Int16* ptr267 = &v[0]) { glVertexAttrib4sv(index, new IntPtr(ptr267)); } 
		}

		public static unsafe void VertexAttrib4(UInt32 index, byte[] v)
		{
			fixed (byte* ptr268 = &v[0]) { glVertexAttrib4ubv(index, new IntPtr(ptr268)); } 
		}

		public static unsafe void VertexAttrib4(UInt32 index, UInt32[] v)
		{
			fixed (UInt32* ptr269 = &v[0]) { glVertexAttrib4uiv(index, new IntPtr(ptr269)); } 
		}

		public static unsafe void VertexAttrib4(UInt32 index, UInt16[] v)
		{
			fixed (UInt16* ptr270 = &v[0]) { glVertexAttrib4usv(index, new IntPtr(ptr270)); } 
		}

		public static unsafe void VertexAttribPointer(UInt32 index, Int32 size, GLEnum type, bool normalized, Int32 stride, IntPtr pointer)
		{
			glVertexAttribPointer(index, size, (uint)type, normalized ? ((byte)1) : ((byte)0), stride, pointer);
		}

		public static unsafe void UniformMatrix2x3fv(Int32 location, Int32 count, bool transpose, float[] val)
		{
			fixed (float* ptr271 = &val[0]) { glUniformMatrix2x3fv(location, count, transpose ? ((byte)1) : ((byte)0), new IntPtr(ptr271)); } 
		}

		public static unsafe void UniformMatrix3x2fv(Int32 location, Int32 count, bool transpose, float[] val)
		{
			fixed (float* ptr272 = &val[0]) { glUniformMatrix3x2fv(location, count, transpose ? ((byte)1) : ((byte)0), new IntPtr(ptr272)); } 
		}

		public static unsafe void UniformMatrix2x4fv(Int32 location, Int32 count, bool transpose, float[] val)
		{
			fixed (float* ptr273 = &val[0]) { glUniformMatrix2x4fv(location, count, transpose ? ((byte)1) : ((byte)0), new IntPtr(ptr273)); } 
		}

		public static unsafe void UniformMatrix4x2fv(Int32 location, Int32 count, bool transpose, float[] val)
		{
			fixed (float* ptr274 = &val[0]) { glUniformMatrix4x2fv(location, count, transpose ? ((byte)1) : ((byte)0), new IntPtr(ptr274)); } 
		}

		public static unsafe void UniformMatrix3x4fv(Int32 location, Int32 count, bool transpose, float[] val)
		{
			fixed (float* ptr275 = &val[0]) { glUniformMatrix3x4fv(location, count, transpose ? ((byte)1) : ((byte)0), new IntPtr(ptr275)); } 
		}

		public static unsafe void UniformMatrix4x3fv(Int32 location, Int32 count, bool transpose, float[] val)
		{
			fixed (float* ptr276 = &val[0]) { glUniformMatrix4x3fv(location, count, transpose ? ((byte)1) : ((byte)0), new IntPtr(ptr276)); } 
		}

		public static unsafe void ColorMaski(UInt32 index, bool r, bool g, bool b, bool a)
		{
			glColorMaski(index, r ? ((byte)1) : ((byte)0), g ? ((byte)1) : ((byte)0), b ? ((byte)1) : ((byte)0), a ? ((byte)1) : ((byte)0));
		}

		public static unsafe void GetBooleani_v(GLEnum target, UInt32 index, [OutAttribute] bool[] data)
		{
			byte[] btr277 = new byte[1];
			fixed (byte* optr277 = btr277) { glGetBooleani_v((uint)target, index, optr277); }
			data = new bool[btr277.Length];
			for (int i277 = 0; i277< data.Length; i277++)
				data[i277] = (btr277[i277] == 1);
			 
		}

		public static unsafe void GetIntegeri_v(GLEnum target, UInt32 index, [OutAttribute] Int32[] data)
		{
			fixed (Int32* optr278 = data) { glGetIntegeri_v((uint)target, index, optr278); } 
		}

		public static unsafe void Enablei(GLEnum target, UInt32 index)
		{
			glEnablei((uint)target, index);
		}

		public static unsafe void Disablei(GLEnum target, UInt32 index)
		{
			glDisablei((uint)target, index);
		}

		public static unsafe bool IsEnabledi(GLEnum target, UInt32 index)
		{
			return (glIsEnabledi((uint)target, index) == 1);
		}

		public static unsafe void BeginTransformFeedback(GLEnum primitiveMode)
		{
			glBeginTransformFeedback((uint)primitiveMode);
		}

		public static unsafe void EndTransformFeedback()
		{
			glEndTransformFeedback();
		}

		public static unsafe void BindBufferRange(GLEnum target, UInt32 index, UInt32 buffer, IntPtr offset, IntPtr size)
		{
			glBindBufferRange((uint)target, index, buffer, offset, size);
		}

		public static unsafe void BindBufferBase(GLEnum target, UInt32 index, UInt32 buffer)
		{
			glBindBufferBase((uint)target, index, buffer);
		}

		public static unsafe void TransformFeedbackVaryings(UInt32 program, Int32 count, IntPtr[] varyings, GLEnum bufferMode)
		{
			fixed (IntPtr* ptr279 = &varyings[0]) { glTransformFeedbackVaryings(program, count, new IntPtr(ptr279), (uint)bufferMode); } 
		}

		public static unsafe void GetTransformFeedbackVarying(UInt32 program, UInt32 index, Int32 bufSize, [OutAttribute] Int32[] length, [OutAttribute] Int32[] size, [OutAttribute] GLEnum[] type, [OutAttribute] byte[] name)
		{
			fixed (byte* optr283 = name) { uint[] unt282 = new uint[type.Length];
			fixed (uint* ptr282 = unt282) { fixed (Int32* optr281 = size) { fixed (Int32* optr280 = length) { glGetTransformFeedbackVarying(program, index, bufSize, optr280, optr281, ptr282, optr283); }  }  } 
			for (int i = 0; i < unt282.Length; i++)
				type[i] = (GLEnum)unt282[i];
			 } 
		}

		public static unsafe void ClampColor(GLEnum target, GLEnum clamp)
		{
			glClampColor((uint)target, (uint)clamp);
		}

		public static unsafe void BeginConditionalRender(UInt32 id, GLEnum mode)
		{
			glBeginConditionalRender(id, (uint)mode);
		}

		public static unsafe void EndConditionalRender()
		{
			glEndConditionalRender();
		}

		public static unsafe void VertexAttribIPointer(UInt32 index, Int32 size, GLEnum type, Int32 stride, IntPtr pointer)
		{
			glVertexAttribIPointer(index, size, (uint)type, stride, pointer);
		}

		public static unsafe void GetVertexAttribIiv(UInt32 index, GLEnum pname, [OutAttribute] Int32[] parameters)
		{
			fixed (Int32* optr284 = parameters) { glGetVertexAttribIiv(index, (uint)pname, optr284); } 
		}

		public static unsafe void GetVertexAttribIuiv(UInt32 index, GLEnum pname, [OutAttribute] UInt32[] parameters)
		{
			fixed (UInt32* optr285 = parameters) { glGetVertexAttribIuiv(index, (uint)pname, optr285); } 
		}

		public static unsafe void VertexAttribI1(UInt32 index, Int32 x)
		{
			glVertexAttribI1i(index, x);
		}

		public static unsafe void VertexAttribI2(UInt32 index, Int32 x, Int32 y)
		{
			glVertexAttribI2i(index, x, y);
		}

		public static unsafe void VertexAttribI3(UInt32 index, Int32 x, Int32 y, Int32 z)
		{
			glVertexAttribI3i(index, x, y, z);
		}

		public static unsafe void VertexAttribI4(UInt32 index, Int32 x, Int32 y, Int32 z, Int32 w)
		{
			glVertexAttribI4i(index, x, y, z, w);
		}

		public static unsafe void VertexAttribI1(UInt32 index, UInt32 x)
		{
			glVertexAttribI1ui(index, x);
		}

		public static unsafe void VertexAttribI2(UInt32 index, UInt32 x, UInt32 y)
		{
			glVertexAttribI2ui(index, x, y);
		}

		public static unsafe void VertexAttribI3(UInt32 index, UInt32 x, UInt32 y, UInt32 z)
		{
			glVertexAttribI3ui(index, x, y, z);
		}

		public static unsafe void VertexAttribI4(UInt32 index, UInt32 x, UInt32 y, UInt32 z, UInt32 w)
		{
			glVertexAttribI4ui(index, x, y, z, w);
		}

		public static unsafe void VertexAttribI1(UInt32 index, Int32[] v)
		{
			fixed (Int32* ptr286 = &v[0]) { glVertexAttribI1iv(index, new IntPtr(ptr286)); } 
		}

		public static unsafe void VertexAttribI2(UInt32 index, Int32[] v)
		{
			fixed (Int32* ptr287 = &v[0]) { glVertexAttribI2iv(index, new IntPtr(ptr287)); } 
		}

		public static unsafe void VertexAttribI3(UInt32 index, Int32[] v)
		{
			fixed (Int32* ptr288 = &v[0]) { glVertexAttribI3iv(index, new IntPtr(ptr288)); } 
		}

		public static unsafe void VertexAttribI4(UInt32 index, Int32[] v)
		{
			fixed (Int32* ptr289 = &v[0]) { glVertexAttribI4iv(index, new IntPtr(ptr289)); } 
		}

		public static unsafe void VertexAttribI1(UInt32 index, UInt32[] v)
		{
			fixed (UInt32* ptr290 = &v[0]) { glVertexAttribI1uiv(index, new IntPtr(ptr290)); } 
		}

		public static unsafe void VertexAttribI2(UInt32 index, UInt32[] v)
		{
			fixed (UInt32* ptr291 = &v[0]) { glVertexAttribI2uiv(index, new IntPtr(ptr291)); } 
		}

		public static unsafe void VertexAttribI3(UInt32 index, UInt32[] v)
		{
			fixed (UInt32* ptr292 = &v[0]) { glVertexAttribI3uiv(index, new IntPtr(ptr292)); } 
		}

		public static unsafe void VertexAttribI4(UInt32 index, UInt32[] v)
		{
			fixed (UInt32* ptr293 = &v[0]) { glVertexAttribI4uiv(index, new IntPtr(ptr293)); } 
		}

		public static unsafe void VertexAttribI4(UInt32 index, SByte[] v)
		{
			fixed (SByte* ptr294 = &v[0]) { glVertexAttribI4bv(index, new IntPtr(ptr294)); } 
		}

		public static unsafe void VertexAttribI4(UInt32 index, Int16[] v)
		{
			fixed (Int16* ptr295 = &v[0]) { glVertexAttribI4sv(index, new IntPtr(ptr295)); } 
		}

		public static unsafe void VertexAttribI4(UInt32 index, byte[] v)
		{
			fixed (byte* ptr296 = &v[0]) { glVertexAttribI4ubv(index, new IntPtr(ptr296)); } 
		}

		public static unsafe void VertexAttribI4(UInt32 index, UInt16[] v)
		{
			fixed (UInt16* ptr297 = &v[0]) { glVertexAttribI4usv(index, new IntPtr(ptr297)); } 
		}

		public static unsafe void GetUniformuiv(UInt32 program, Int32 location, [OutAttribute] UInt32[] parameters)
		{
			fixed (UInt32* optr298 = parameters) { glGetUniformuiv(program, location, optr298); } 
		}

		public static unsafe void BindFragDataLocation(UInt32 program, UInt32 color, byte[] name)
		{
			fixed (byte* ptr299 = &name[0]) { glBindFragDataLocation(program, color, new IntPtr(ptr299)); } 
		}

		public static unsafe Int32 GetFragDataLocation(UInt32 program, byte[] name)
		{
			fixed (byte* ptr300 = &name[0]) { return glGetFragDataLocation(program, new IntPtr(ptr300)); } 
		}

		public static unsafe void Uniform1(Int32 location, UInt32 v0)
		{
			glUniform1ui(location, v0);
		}

		public static unsafe void Uniform2(Int32 location, UInt32 v0, UInt32 v1)
		{
			glUniform2ui(location, v0, v1);
		}

		public static unsafe void Uniform3(Int32 location, UInt32 v0, UInt32 v1, UInt32 v2)
		{
			glUniform3ui(location, v0, v1, v2);
		}

		public static unsafe void Uniform4(Int32 location, UInt32 v0, UInt32 v1, UInt32 v2, UInt32 v3)
		{
			glUniform4ui(location, v0, v1, v2, v3);
		}

		public static unsafe void Uniform1(Int32 location, Int32 count, UInt32[] val)
		{
			fixed (UInt32* ptr301 = &val[0]) { glUniform1uiv(location, count, new IntPtr(ptr301)); } 
		}

		public static unsafe void Uniform2(Int32 location, Int32 count, UInt32[] val)
		{
			fixed (UInt32* ptr302 = &val[0]) { glUniform2uiv(location, count, new IntPtr(ptr302)); } 
		}

		public static unsafe void Uniform3(Int32 location, Int32 count, UInt32[] val)
		{
			fixed (UInt32* ptr303 = &val[0]) { glUniform3uiv(location, count, new IntPtr(ptr303)); } 
		}

		public static unsafe void Uniform4(Int32 location, Int32 count, UInt32[] val)
		{
			fixed (UInt32* ptr304 = &val[0]) { glUniform4uiv(location, count, new IntPtr(ptr304)); } 
		}

		public static unsafe void TexParameterI(TextureTarget target, TextureParameterName pname, Int32[] parameters)
		{
			fixed (Int32* ptr305 = &parameters[0]) { glTexParameterIiv((uint)target, (uint)pname, new IntPtr(ptr305)); } 
		}

		public static unsafe void TexParameterI(TextureTarget target, TextureParameterName pname, UInt32[] parameters)
		{
			fixed (UInt32* ptr306 = &parameters[0]) { glTexParameterIuiv((uint)target, (uint)pname, new IntPtr(ptr306)); } 
		}

		public static unsafe void GetTexParameterIiv(TextureTarget target, GetTextureParameter pname, [OutAttribute] Int32[] parameters)
		{
			fixed (Int32* optr307 = parameters) { glGetTexParameterIiv((uint)target, (uint)pname, optr307); } 
		}

		public static unsafe void GetTexParameterIuiv(TextureTarget target, GetTextureParameter pname, [OutAttribute] UInt32[] parameters)
		{
			fixed (UInt32* optr308 = parameters) { glGetTexParameterIuiv((uint)target, (uint)pname, optr308); } 
		}

		public static unsafe void ClearBufferiv(GLEnum buffer, Int32 drawbuffer, Int32[] val)
		{
			fixed (Int32* ptr309 = &val[0]) { glClearBufferiv((uint)buffer, drawbuffer, new IntPtr(ptr309)); } 
		}

		public static unsafe void ClearBufferuiv(GLEnum buffer, Int32 drawbuffer, UInt32[] val)
		{
			fixed (UInt32* ptr310 = &val[0]) { glClearBufferuiv((uint)buffer, drawbuffer, new IntPtr(ptr310)); } 
		}

		public static unsafe void ClearBufferfv(GLEnum buffer, Int32 drawbuffer, float[] val)
		{
			fixed (float* ptr311 = &val[0]) { glClearBufferfv((uint)buffer, drawbuffer, new IntPtr(ptr311)); } 
		}

		public static unsafe void ClearBufferfi(GLEnum buffer, Int32 drawbuffer, float depth, Int32 stencil)
		{
			glClearBufferfi((uint)buffer, drawbuffer, depth, stencil);
		}

		public static unsafe IntPtr GetStringi(GLEnum name, UInt32 index)
		{
			return glGetStringi((uint)name, index);
		}

		public static unsafe void DrawArraysInstanced(BeginMode mode, Int32 first, Int32 count, Int32 primcount)
		{
			glDrawArraysInstanced((uint)mode, first, count, primcount);
		}

		public static unsafe void DrawElementsInstanced(BeginMode mode, Int32 count, GLEnum type, IntPtr indices, Int32 primcount)
		{
			glDrawElementsInstanced((uint)mode, count, (uint)type, indices, primcount);
		}

		public static unsafe void TexBuffer(TextureTarget target, GLEnum internalformat, UInt32 buffer)
		{
			glTexBuffer((uint)target, (uint)internalformat, buffer);
		}

		public static unsafe void PrimitiveRestartIndex(UInt32 index)
		{
			glPrimitiveRestartIndex(index);
		}

		public static unsafe void GetInteger64i_v(GLEnum target, UInt32 index, [OutAttribute] Int64[] data)
		{
			fixed (Int64* optr312 = data) { glGetInteger64i_v((uint)target, index, optr312); } 
		}

		public static unsafe void GetBufferParameteri64v(GLEnum target, GLEnum pname, [OutAttribute] Int64[] parameters)
		{
			fixed (Int64* optr313 = parameters) { glGetBufferParameteri64v((uint)target, (uint)pname, optr313); } 
		}

		public static unsafe void ProgramParameter(UInt32 program, GLEnum pname, Int32 val)
		{
			glProgramParameteri(program, (uint)pname, val);
		}

		public static unsafe void FramebufferTexture(GLEnum target, GLEnum attachment, UInt32 texture, Int32 level)
		{
			glFramebufferTexture((uint)target, (uint)attachment, texture, level);
		}

		public static unsafe void ActiveTextureARB(GLEnum texture)
		{
			glActiveTextureARB((uint)texture);
		}

		public static unsafe void ClientActiveTextureARB(GLEnum texture)
		{
			glClientActiveTextureARB((uint)texture);
		}

		public static unsafe void MultiTexCoord1dARB(GLEnum target, double s)
		{
			glMultiTexCoord1dARB((uint)target, s);
		}

		public static unsafe void MultiTexCoord1dvARB(GLEnum target, double[] v)
		{
			fixed (double* ptr314 = &v[0]) { glMultiTexCoord1dvARB((uint)target, new IntPtr(ptr314)); } 
		}

		public static unsafe void MultiTexCoord1fARB(GLEnum target, float s)
		{
			glMultiTexCoord1fARB((uint)target, s);
		}

		public static unsafe void MultiTexCoord1fvARB(GLEnum target, float[] v)
		{
			fixed (float* ptr315 = &v[0]) { glMultiTexCoord1fvARB((uint)target, new IntPtr(ptr315)); } 
		}

		public static unsafe void MultiTexCoord1iARB(GLEnum target, Int32 s)
		{
			glMultiTexCoord1iARB((uint)target, s);
		}

		public static unsafe void MultiTexCoord1ivARB(GLEnum target, Int32[] v)
		{
			fixed (Int32* ptr316 = &v[0]) { glMultiTexCoord1ivARB((uint)target, new IntPtr(ptr316)); } 
		}

		public static unsafe void MultiTexCoord1sARB(GLEnum target, Int16 s)
		{
			glMultiTexCoord1sARB((uint)target, s);
		}

		public static unsafe void MultiTexCoord1svARB(GLEnum target, Int16[] v)
		{
			fixed (Int16* ptr317 = &v[0]) { glMultiTexCoord1svARB((uint)target, new IntPtr(ptr317)); } 
		}

		public static unsafe void MultiTexCoord2dARB(GLEnum target, double s, double t)
		{
			glMultiTexCoord2dARB((uint)target, s, t);
		}

		public static unsafe void MultiTexCoord2dvARB(GLEnum target, double[] v)
		{
			fixed (double* ptr318 = &v[0]) { glMultiTexCoord2dvARB((uint)target, new IntPtr(ptr318)); } 
		}

		public static unsafe void MultiTexCoord2fARB(GLEnum target, float s, float t)
		{
			glMultiTexCoord2fARB((uint)target, s, t);
		}

		public static unsafe void MultiTexCoord2fvARB(GLEnum target, float[] v)
		{
			fixed (float* ptr319 = &v[0]) { glMultiTexCoord2fvARB((uint)target, new IntPtr(ptr319)); } 
		}

		public static unsafe void MultiTexCoord2iARB(GLEnum target, Int32 s, Int32 t)
		{
			glMultiTexCoord2iARB((uint)target, s, t);
		}

		public static unsafe void MultiTexCoord2ivARB(GLEnum target, Int32[] v)
		{
			fixed (Int32* ptr320 = &v[0]) { glMultiTexCoord2ivARB((uint)target, new IntPtr(ptr320)); } 
		}

		public static unsafe void MultiTexCoord2sARB(GLEnum target, Int16 s, Int16 t)
		{
			glMultiTexCoord2sARB((uint)target, s, t);
		}

		public static unsafe void MultiTexCoord2svARB(GLEnum target, Int16[] v)
		{
			fixed (Int16* ptr321 = &v[0]) { glMultiTexCoord2svARB((uint)target, new IntPtr(ptr321)); } 
		}

		public static unsafe void MultiTexCoord3dARB(GLEnum target, double s, double t, double r)
		{
			glMultiTexCoord3dARB((uint)target, s, t, r);
		}

		public static unsafe void MultiTexCoord3dvARB(GLEnum target, double[] v)
		{
			fixed (double* ptr322 = &v[0]) { glMultiTexCoord3dvARB((uint)target, new IntPtr(ptr322)); } 
		}

		public static unsafe void MultiTexCoord3fARB(GLEnum target, float s, float t, float r)
		{
			glMultiTexCoord3fARB((uint)target, s, t, r);
		}

		public static unsafe void MultiTexCoord3fvARB(GLEnum target, float[] v)
		{
			fixed (float* ptr323 = &v[0]) { glMultiTexCoord3fvARB((uint)target, new IntPtr(ptr323)); } 
		}

		public static unsafe void MultiTexCoord3iARB(GLEnum target, Int32 s, Int32 t, Int32 r)
		{
			glMultiTexCoord3iARB((uint)target, s, t, r);
		}

		public static unsafe void MultiTexCoord3ivARB(GLEnum target, Int32[] v)
		{
			fixed (Int32* ptr324 = &v[0]) { glMultiTexCoord3ivARB((uint)target, new IntPtr(ptr324)); } 
		}

		public static unsafe void MultiTexCoord3sARB(GLEnum target, Int16 s, Int16 t, Int16 r)
		{
			glMultiTexCoord3sARB((uint)target, s, t, r);
		}

		public static unsafe void MultiTexCoord3svARB(GLEnum target, Int16[] v)
		{
			fixed (Int16* ptr325 = &v[0]) { glMultiTexCoord3svARB((uint)target, new IntPtr(ptr325)); } 
		}

		public static unsafe void MultiTexCoord4dARB(GLEnum target, double s, double t, double r, double q)
		{
			glMultiTexCoord4dARB((uint)target, s, t, r, q);
		}

		public static unsafe void MultiTexCoord4dvARB(GLEnum target, double[] v)
		{
			fixed (double* ptr326 = &v[0]) { glMultiTexCoord4dvARB((uint)target, new IntPtr(ptr326)); } 
		}

		public static unsafe void MultiTexCoord4fARB(GLEnum target, float s, float t, float r, float q)
		{
			glMultiTexCoord4fARB((uint)target, s, t, r, q);
		}

		public static unsafe void MultiTexCoord4fvARB(GLEnum target, float[] v)
		{
			fixed (float* ptr327 = &v[0]) { glMultiTexCoord4fvARB((uint)target, new IntPtr(ptr327)); } 
		}

		public static unsafe void MultiTexCoord4iARB(GLEnum target, Int32 s, Int32 t, Int32 r, Int32 q)
		{
			glMultiTexCoord4iARB((uint)target, s, t, r, q);
		}

		public static unsafe void MultiTexCoord4ivARB(GLEnum target, Int32[] v)
		{
			fixed (Int32* ptr328 = &v[0]) { glMultiTexCoord4ivARB((uint)target, new IntPtr(ptr328)); } 
		}

		public static unsafe void MultiTexCoord4sARB(GLEnum target, Int16 s, Int16 t, Int16 r, Int16 q)
		{
			glMultiTexCoord4sARB((uint)target, s, t, r, q);
		}

		public static unsafe void MultiTexCoord4svARB(GLEnum target, Int16[] v)
		{
			fixed (Int16* ptr329 = &v[0]) { glMultiTexCoord4svARB((uint)target, new IntPtr(ptr329)); } 
		}

		public static unsafe void LoadTransposeMatrixfARB(float[] m)
		{
			fixed (float* ptr330 = &m[0]) { glLoadTransposeMatrixfARB(new IntPtr(ptr330)); } 
		}

		public static unsafe void LoadTransposeMatrixdARB(double[] m)
		{
			fixed (double* ptr331 = &m[0]) { glLoadTransposeMatrixdARB(new IntPtr(ptr331)); } 
		}

		public static unsafe void MultTransposeMatrixfARB(float[] m)
		{
			fixed (float* ptr332 = &m[0]) { glMultTransposeMatrixfARB(new IntPtr(ptr332)); } 
		}

		public static unsafe void MultTransposeMatrixdARB(double[] m)
		{
			fixed (double* ptr333 = &m[0]) { glMultTransposeMatrixdARB(new IntPtr(ptr333)); } 
		}

		public static unsafe void SampleCoverageARB(float val, bool invert)
		{
			glSampleCoverageARB(val, invert ? ((byte)1) : ((byte)0));
		}

		public static unsafe void CompressedTexImage3DARB(TextureTarget target, Int32 level, PixelInternalFormat internalformat, Int32 width, Int32 height, Int32 depth, Int32 border, Int32 imageSize, IntPtr data)
		{
			glCompressedTexImage3DARB((uint)target, level, (uint)internalformat, width, height, depth, border, imageSize, data);
		}

		public static unsafe void CompressedTexImage2DARB(TextureTarget target, Int32 level, PixelInternalFormat internalformat, Int32 width, Int32 height, Int32 border, Int32 imageSize, IntPtr data)
		{
			glCompressedTexImage2DARB((uint)target, level, (uint)internalformat, width, height, border, imageSize, data);
		}

		public static unsafe void CompressedTexImage1DARB(TextureTarget target, Int32 level, PixelInternalFormat internalformat, Int32 width, Int32 border, Int32 imageSize, IntPtr data)
		{
			glCompressedTexImage1DARB((uint)target, level, (uint)internalformat, width, border, imageSize, data);
		}

		public static unsafe void CompressedTexSubImage3DARB(TextureTarget target, Int32 level, Int32 xoffset, Int32 yoffset, Int32 zoffset, Int32 width, Int32 height, Int32 depth, PixelFormat format, Int32 imageSize, IntPtr data)
		{
			glCompressedTexSubImage3DARB((uint)target, level, xoffset, yoffset, zoffset, width, height, depth, (uint)format, imageSize, data);
		}

		public static unsafe void CompressedTexSubImage2DARB(TextureTarget target, Int32 level, Int32 xoffset, Int32 yoffset, Int32 width, Int32 height, PixelFormat format, Int32 imageSize, IntPtr data)
		{
			glCompressedTexSubImage2DARB((uint)target, level, xoffset, yoffset, width, height, (uint)format, imageSize, data);
		}

		public static unsafe void CompressedTexSubImage1DARB(TextureTarget target, Int32 level, Int32 xoffset, Int32 width, PixelFormat format, Int32 imageSize, IntPtr data)
		{
			glCompressedTexSubImage1DARB((uint)target, level, xoffset, width, (uint)format, imageSize, data);
		}

		public static unsafe void GetCompressedTexImageARB(TextureTarget target, Int32 level, [OutAttribute] IntPtr img)
		{
			glGetCompressedTexImageARB((uint)target, level, img);
		}

		public static unsafe void PointParameterfARB(GLEnum pname, float param)
		{
			glPointParameterfARB((uint)pname, param);
		}

		public static unsafe void PointParameterfvARB(GLEnum pname, float[] parameters)
		{
			fixed (float* ptr334 = &parameters[0]) { glPointParameterfvARB((uint)pname, new IntPtr(ptr334)); } 
		}

		public static unsafe void WeightbvARB(Int32 size, SByte[] weights)
		{
			fixed (SByte* ptr335 = &weights[0]) { glWeightbvARB(size, new IntPtr(ptr335)); } 
		}

		public static unsafe void WeightsvARB(Int32 size, Int16[] weights)
		{
			fixed (Int16* ptr336 = &weights[0]) { glWeightsvARB(size, new IntPtr(ptr336)); } 
		}

		public static unsafe void WeightivARB(Int32 size, Int32[] weights)
		{
			fixed (Int32* ptr337 = &weights[0]) { glWeightivARB(size, new IntPtr(ptr337)); } 
		}

		public static unsafe void WeightfvARB(Int32 size, float[] weights)
		{
			fixed (float* ptr338 = &weights[0]) { glWeightfvARB(size, new IntPtr(ptr338)); } 
		}

		public static unsafe void WeightdvARB(Int32 size, double[] weights)
		{
			fixed (double* ptr339 = &weights[0]) { glWeightdvARB(size, new IntPtr(ptr339)); } 
		}

		public static unsafe void WeightubvARB(Int32 size, byte[] weights)
		{
			fixed (byte* ptr340 = &weights[0]) { glWeightubvARB(size, new IntPtr(ptr340)); } 
		}

		public static unsafe void WeightusvARB(Int32 size, UInt16[] weights)
		{
			fixed (UInt16* ptr341 = &weights[0]) { glWeightusvARB(size, new IntPtr(ptr341)); } 
		}

		public static unsafe void WeightuivARB(Int32 size, UInt32[] weights)
		{
			fixed (UInt32* ptr342 = &weights[0]) { glWeightuivARB(size, new IntPtr(ptr342)); } 
		}

		public static unsafe void WeightPointerARB(Int32 size, GLEnum type, Int32 stride, IntPtr pointer)
		{
			glWeightPointerARB(size, (uint)type, stride, pointer);
		}

		public static unsafe void VertexBlendARB(Int32 count)
		{
			glVertexBlendARB(count);
		}

		public static unsafe void CurrentPaletteMatrixARB(Int32 index)
		{
			glCurrentPaletteMatrixARB(index);
		}

		public static unsafe void MatrixIndexubvARB(Int32 size, byte[] indices)
		{
			fixed (byte* ptr343 = &indices[0]) { glMatrixIndexubvARB(size, new IntPtr(ptr343)); } 
		}

		public static unsafe void MatrixIndexusvARB(Int32 size, UInt16[] indices)
		{
			fixed (UInt16* ptr344 = &indices[0]) { glMatrixIndexusvARB(size, new IntPtr(ptr344)); } 
		}

		public static unsafe void MatrixIndexuivARB(Int32 size, UInt32[] indices)
		{
			fixed (UInt32* ptr345 = &indices[0]) { glMatrixIndexuivARB(size, new IntPtr(ptr345)); } 
		}

		public static unsafe void MatrixIndexPointerARB(Int32 size, GLEnum type, Int32 stride, IntPtr pointer)
		{
			glMatrixIndexPointerARB(size, (uint)type, stride, pointer);
		}

		public static unsafe void WindowPos2dARB(double x, double y)
		{
			glWindowPos2dARB(x, y);
		}

		public static unsafe void WindowPos2dvARB(double[] v)
		{
			fixed (double* ptr346 = &v[0]) { glWindowPos2dvARB(new IntPtr(ptr346)); } 
		}

		public static unsafe void WindowPos2fARB(float x, float y)
		{
			glWindowPos2fARB(x, y);
		}

		public static unsafe void WindowPos2fvARB(float[] v)
		{
			fixed (float* ptr347 = &v[0]) { glWindowPos2fvARB(new IntPtr(ptr347)); } 
		}

		public static unsafe void WindowPos2iARB(Int32 x, Int32 y)
		{
			glWindowPos2iARB(x, y);
		}

		public static unsafe void WindowPos2ivARB(Int32[] v)
		{
			fixed (Int32* ptr348 = &v[0]) { glWindowPos2ivARB(new IntPtr(ptr348)); } 
		}

		public static unsafe void WindowPos2sARB(Int16 x, Int16 y)
		{
			glWindowPos2sARB(x, y);
		}

		public static unsafe void WindowPos2svARB(Int16[] v)
		{
			fixed (Int16* ptr349 = &v[0]) { glWindowPos2svARB(new IntPtr(ptr349)); } 
		}

		public static unsafe void WindowPos3dARB(double x, double y, double z)
		{
			glWindowPos3dARB(x, y, z);
		}

		public static unsafe void WindowPos3dvARB(double[] v)
		{
			fixed (double* ptr350 = &v[0]) { glWindowPos3dvARB(new IntPtr(ptr350)); } 
		}

		public static unsafe void WindowPos3fARB(float x, float y, float z)
		{
			glWindowPos3fARB(x, y, z);
		}

		public static unsafe void WindowPos3fvARB(float[] v)
		{
			fixed (float* ptr351 = &v[0]) { glWindowPos3fvARB(new IntPtr(ptr351)); } 
		}

		public static unsafe void WindowPos3iARB(Int32 x, Int32 y, Int32 z)
		{
			glWindowPos3iARB(x, y, z);
		}

		public static unsafe void WindowPos3ivARB(Int32[] v)
		{
			fixed (Int32* ptr352 = &v[0]) { glWindowPos3ivARB(new IntPtr(ptr352)); } 
		}

		public static unsafe void WindowPos3sARB(Int16 x, Int16 y, Int16 z)
		{
			glWindowPos3sARB(x, y, z);
		}

		public static unsafe void WindowPos3svARB(Int16[] v)
		{
			fixed (Int16* ptr353 = &v[0]) { glWindowPos3svARB(new IntPtr(ptr353)); } 
		}

		public static unsafe void VertexAttrib1dARB(UInt32 index, double x)
		{
			glVertexAttrib1dARB(index, x);
		}

		public static unsafe void VertexAttrib1dvARB(UInt32 index, double[] v)
		{
			fixed (double* ptr354 = &v[0]) { glVertexAttrib1dvARB(index, new IntPtr(ptr354)); } 
		}

		public static unsafe void VertexAttrib1fARB(UInt32 index, float x)
		{
			glVertexAttrib1fARB(index, x);
		}

		public static unsafe void VertexAttrib1fvARB(UInt32 index, float[] v)
		{
			fixed (float* ptr355 = &v[0]) { glVertexAttrib1fvARB(index, new IntPtr(ptr355)); } 
		}

		public static unsafe void VertexAttrib1sARB(UInt32 index, Int16 x)
		{
			glVertexAttrib1sARB(index, x);
		}

		public static unsafe void VertexAttrib1svARB(UInt32 index, Int16[] v)
		{
			fixed (Int16* ptr356 = &v[0]) { glVertexAttrib1svARB(index, new IntPtr(ptr356)); } 
		}

		public static unsafe void VertexAttrib2dARB(UInt32 index, double x, double y)
		{
			glVertexAttrib2dARB(index, x, y);
		}

		public static unsafe void VertexAttrib2dvARB(UInt32 index, double[] v)
		{
			fixed (double* ptr357 = &v[0]) { glVertexAttrib2dvARB(index, new IntPtr(ptr357)); } 
		}

		public static unsafe void VertexAttrib2fARB(UInt32 index, float x, float y)
		{
			glVertexAttrib2fARB(index, x, y);
		}

		public static unsafe void VertexAttrib2fvARB(UInt32 index, float[] v)
		{
			fixed (float* ptr358 = &v[0]) { glVertexAttrib2fvARB(index, new IntPtr(ptr358)); } 
		}

		public static unsafe void VertexAttrib2sARB(UInt32 index, Int16 x, Int16 y)
		{
			glVertexAttrib2sARB(index, x, y);
		}

		public static unsafe void VertexAttrib2svARB(UInt32 index, Int16[] v)
		{
			fixed (Int16* ptr359 = &v[0]) { glVertexAttrib2svARB(index, new IntPtr(ptr359)); } 
		}

		public static unsafe void VertexAttrib3dARB(UInt32 index, double x, double y, double z)
		{
			glVertexAttrib3dARB(index, x, y, z);
		}

		public static unsafe void VertexAttrib3dvARB(UInt32 index, double[] v)
		{
			fixed (double* ptr360 = &v[0]) { glVertexAttrib3dvARB(index, new IntPtr(ptr360)); } 
		}

		public static unsafe void VertexAttrib3fARB(UInt32 index, float x, float y, float z)
		{
			glVertexAttrib3fARB(index, x, y, z);
		}

		public static unsafe void VertexAttrib3fvARB(UInt32 index, float[] v)
		{
			fixed (float* ptr361 = &v[0]) { glVertexAttrib3fvARB(index, new IntPtr(ptr361)); } 
		}

		public static unsafe void VertexAttrib3sARB(UInt32 index, Int16 x, Int16 y, Int16 z)
		{
			glVertexAttrib3sARB(index, x, y, z);
		}

		public static unsafe void VertexAttrib3svARB(UInt32 index, Int16[] v)
		{
			fixed (Int16* ptr362 = &v[0]) { glVertexAttrib3svARB(index, new IntPtr(ptr362)); } 
		}

		public static unsafe void VertexAttrib4NbvARB(UInt32 index, SByte[] v)
		{
			fixed (SByte* ptr363 = &v[0]) { glVertexAttrib4NbvARB(index, new IntPtr(ptr363)); } 
		}

		public static unsafe void VertexAttrib4NivARB(UInt32 index, Int32[] v)
		{
			fixed (Int32* ptr364 = &v[0]) { glVertexAttrib4NivARB(index, new IntPtr(ptr364)); } 
		}

		public static unsafe void VertexAttrib4NsvARB(UInt32 index, Int16[] v)
		{
			fixed (Int16* ptr365 = &v[0]) { glVertexAttrib4NsvARB(index, new IntPtr(ptr365)); } 
		}

		public static unsafe void VertexAttrib4NubARB(UInt32 index, byte x, byte y, byte z, byte w)
		{
			glVertexAttrib4NubARB(index, x, y, z, w);
		}

		public static unsafe void VertexAttrib4NubvARB(UInt32 index, byte[] v)
		{
			fixed (byte* ptr366 = &v[0]) { glVertexAttrib4NubvARB(index, new IntPtr(ptr366)); } 
		}

		public static unsafe void VertexAttrib4NuivARB(UInt32 index, UInt32[] v)
		{
			fixed (UInt32* ptr367 = &v[0]) { glVertexAttrib4NuivARB(index, new IntPtr(ptr367)); } 
		}

		public static unsafe void VertexAttrib4NusvARB(UInt32 index, UInt16[] v)
		{
			fixed (UInt16* ptr368 = &v[0]) { glVertexAttrib4NusvARB(index, new IntPtr(ptr368)); } 
		}

		public static unsafe void VertexAttrib4bvARB(UInt32 index, SByte[] v)
		{
			fixed (SByte* ptr369 = &v[0]) { glVertexAttrib4bvARB(index, new IntPtr(ptr369)); } 
		}

		public static unsafe void VertexAttrib4dARB(UInt32 index, double x, double y, double z, double w)
		{
			glVertexAttrib4dARB(index, x, y, z, w);
		}

		public static unsafe void VertexAttrib4dvARB(UInt32 index, double[] v)
		{
			fixed (double* ptr370 = &v[0]) { glVertexAttrib4dvARB(index, new IntPtr(ptr370)); } 
		}

		public static unsafe void VertexAttrib4fARB(UInt32 index, float x, float y, float z, float w)
		{
			glVertexAttrib4fARB(index, x, y, z, w);
		}

		public static unsafe void VertexAttrib4fvARB(UInt32 index, float[] v)
		{
			fixed (float* ptr371 = &v[0]) { glVertexAttrib4fvARB(index, new IntPtr(ptr371)); } 
		}

		public static unsafe void VertexAttrib4ivARB(UInt32 index, Int32[] v)
		{
			fixed (Int32* ptr372 = &v[0]) { glVertexAttrib4ivARB(index, new IntPtr(ptr372)); } 
		}

		public static unsafe void VertexAttrib4sARB(UInt32 index, Int16 x, Int16 y, Int16 z, Int16 w)
		{
			glVertexAttrib4sARB(index, x, y, z, w);
		}

		public static unsafe void VertexAttrib4svARB(UInt32 index, Int16[] v)
		{
			fixed (Int16* ptr373 = &v[0]) { glVertexAttrib4svARB(index, new IntPtr(ptr373)); } 
		}

		public static unsafe void VertexAttrib4ubvARB(UInt32 index, byte[] v)
		{
			fixed (byte* ptr374 = &v[0]) { glVertexAttrib4ubvARB(index, new IntPtr(ptr374)); } 
		}

		public static unsafe void VertexAttrib4uivARB(UInt32 index, UInt32[] v)
		{
			fixed (UInt32* ptr375 = &v[0]) { glVertexAttrib4uivARB(index, new IntPtr(ptr375)); } 
		}

		public static unsafe void VertexAttrib4usvARB(UInt32 index, UInt16[] v)
		{
			fixed (UInt16* ptr376 = &v[0]) { glVertexAttrib4usvARB(index, new IntPtr(ptr376)); } 
		}

		public static unsafe void VertexAttribPointerARB(UInt32 index, Int32 size, GLEnum type, bool normalized, Int32 stride, IntPtr pointer)
		{
			glVertexAttribPointerARB(index, size, (uint)type, normalized ? ((byte)1) : ((byte)0), stride, pointer);
		}

		public static unsafe void EnableVertexAttribArrayARB(UInt32 index)
		{
			glEnableVertexAttribArrayARB(index);
		}

		public static unsafe void DisableVertexAttribArrayARB(UInt32 index)
		{
			glDisableVertexAttribArrayARB(index);
		}

		public static unsafe void ProgramStringARB(GLEnum target, GLEnum format, Int32 len, IntPtr str)
		{
			glProgramStringARB((uint)target, (uint)format, len, str);
		}

		public static unsafe void BindProgramARB(GLEnum target, UInt32 program)
		{
			glBindProgramARB((uint)target, program);
		}

		public static unsafe void DeleteProgramsARB(Int32 n, UInt32[] programs)
		{
			fixed (UInt32* ptr377 = &programs[0]) { glDeleteProgramsARB(n, new IntPtr(ptr377)); } 
		}

		public static unsafe void GenProgramsARB(Int32 n, [OutAttribute] UInt32[] programs)
		{
			fixed (UInt32* optr378 = programs) { glGenProgramsARB(n, optr378); } 
		}

		public static unsafe void ProgramEnvParameter4dARB(GLEnum target, UInt32 index, double x, double y, double z, double w)
		{
			glProgramEnvParameter4dARB((uint)target, index, x, y, z, w);
		}

		public static unsafe void ProgramEnvParameter4dvARB(GLEnum target, UInt32 index, double[] parameters)
		{
			fixed (double* ptr379 = &parameters[0]) { glProgramEnvParameter4dvARB((uint)target, index, new IntPtr(ptr379)); } 
		}

		public static unsafe void ProgramEnvParameter4fARB(GLEnum target, UInt32 index, float x, float y, float z, float w)
		{
			glProgramEnvParameter4fARB((uint)target, index, x, y, z, w);
		}

		public static unsafe void ProgramEnvParameter4fvARB(GLEnum target, UInt32 index, float[] parameters)
		{
			fixed (float* ptr380 = &parameters[0]) { glProgramEnvParameter4fvARB((uint)target, index, new IntPtr(ptr380)); } 
		}

		public static unsafe void ProgramLocalParameter4dARB(GLEnum target, UInt32 index, double x, double y, double z, double w)
		{
			glProgramLocalParameter4dARB((uint)target, index, x, y, z, w);
		}

		public static unsafe void ProgramLocalParameter4dvARB(GLEnum target, UInt32 index, double[] parameters)
		{
			fixed (double* ptr381 = &parameters[0]) { glProgramLocalParameter4dvARB((uint)target, index, new IntPtr(ptr381)); } 
		}

		public static unsafe void ProgramLocalParameter4fARB(GLEnum target, UInt32 index, float x, float y, float z, float w)
		{
			glProgramLocalParameter4fARB((uint)target, index, x, y, z, w);
		}

		public static unsafe void ProgramLocalParameter4fvARB(GLEnum target, UInt32 index, float[] parameters)
		{
			fixed (float* ptr382 = &parameters[0]) { glProgramLocalParameter4fvARB((uint)target, index, new IntPtr(ptr382)); } 
		}

		public static unsafe void GetProgramEnvParameterdvARB(GLEnum target, UInt32 index, [OutAttribute] double[] parameters)
		{
			fixed (double* optr383 = parameters) { glGetProgramEnvParameterdvARB((uint)target, index, optr383); } 
		}

		public static unsafe void GetProgramEnvParameterfvARB(GLEnum target, UInt32 index, [OutAttribute] float[] parameters)
		{
			fixed (float* optr384 = parameters) { glGetProgramEnvParameterfvARB((uint)target, index, optr384); } 
		}

		public static unsafe void GetProgramLocalParameterdvARB(GLEnum target, UInt32 index, [OutAttribute] double[] parameters)
		{
			fixed (double* optr385 = parameters) { glGetProgramLocalParameterdvARB((uint)target, index, optr385); } 
		}

		public static unsafe void GetProgramLocalParameterfvARB(GLEnum target, UInt32 index, [OutAttribute] float[] parameters)
		{
			fixed (float* optr386 = parameters) { glGetProgramLocalParameterfvARB((uint)target, index, optr386); } 
		}

		public static unsafe void GetProgramivARB(GLEnum target, GLEnum pname, [OutAttribute] Int32[] parameters)
		{
			fixed (Int32* optr387 = parameters) { glGetProgramivARB((uint)target, (uint)pname, optr387); } 
		}

		public static unsafe void GetProgramStringARB(GLEnum target, GLEnum pname, [OutAttribute] IntPtr str)
		{
			glGetProgramStringARB((uint)target, (uint)pname, str);
		}

		public static unsafe void GetVertexAttribdvARB(UInt32 index, GLEnum pname, [OutAttribute] double[] parameters)
		{
			fixed (double* optr388 = parameters) { glGetVertexAttribdvARB(index, (uint)pname, optr388); } 
		}

		public static unsafe void GetVertexAttribfvARB(UInt32 index, GLEnum pname, [OutAttribute] float[] parameters)
		{
			fixed (float* optr389 = parameters) { glGetVertexAttribfvARB(index, (uint)pname, optr389); } 
		}

		public static unsafe void GetVertexAttribivARB(UInt32 index, GLEnum pname, [OutAttribute] Int32[] parameters)
		{
			fixed (Int32* optr390 = parameters) { glGetVertexAttribivARB(index, (uint)pname, optr390); } 
		}

		public static unsafe void GetVertexAttribPointervARB(UInt32 index, GLEnum pname, [OutAttribute] IntPtr[] pointer)
		{
			fixed (IntPtr* optr391 = pointer) { glGetVertexAttribPointervARB(index, (uint)pname, optr391); } 
		}

		public static unsafe bool IsProgramARB(UInt32 program)
		{
			return (glIsProgramARB(program) == 1);
		}

		public static unsafe void BindBufferARB(GLEnum target, UInt32 buffer)
		{
			glBindBufferARB((uint)target, buffer);
		}

		public static unsafe void DeleteBuffersARB(Int32 n, UInt32[] buffers)
		{
			fixed (UInt32* ptr392 = &buffers[0]) { glDeleteBuffersARB(n, new IntPtr(ptr392)); } 
		}

		public static unsafe void GenBuffersARB(Int32 n, [OutAttribute] UInt32[] buffers)
		{
			fixed (UInt32* optr393 = buffers) { glGenBuffersARB(n, optr393); } 
		}

		public static unsafe bool IsBufferARB(UInt32 buffer)
		{
			return (glIsBufferARB(buffer) == 1);
		}

		public static unsafe void BufferDataARB(GLEnum target, IntPtr size, IntPtr data, GLEnum usage)
		{
			glBufferDataARB((uint)target, size, data, (uint)usage);
		}

		public static unsafe void BufferSubDataARB(GLEnum target, IntPtr offset, IntPtr size, IntPtr data)
		{
			glBufferSubDataARB((uint)target, offset, size, data);
		}

		public static unsafe void GetBufferSubDataARB(GLEnum target, IntPtr offset, IntPtr size, [OutAttribute] IntPtr data)
		{
			glGetBufferSubDataARB((uint)target, offset, size, data);
		}

		public static unsafe IntPtr MapBufferARB(GLEnum target, GLEnum access)
		{
			return glMapBufferARB((uint)target, (uint)access);
		}

		public static unsafe bool UnmapBufferARB(GLEnum target)
		{
			return (glUnmapBufferARB((uint)target) == 1);
		}

		public static unsafe void GetBufferParameterivARB(GLEnum target, GLEnum pname, [OutAttribute] Int32[] parameters)
		{
			fixed (Int32* optr394 = parameters) { glGetBufferParameterivARB((uint)target, (uint)pname, optr394); } 
		}

		public static unsafe void GetBufferPointervARB(GLEnum target, GLEnum pname, [OutAttribute] IntPtr[] parameters)
		{
			fixed (IntPtr* optr395 = parameters) { glGetBufferPointervARB((uint)target, (uint)pname, optr395); } 
		}

		public static unsafe void GenQueriesARB(Int32 n, [OutAttribute] UInt32[] ids)
		{
			fixed (UInt32* optr396 = ids) { glGenQueriesARB(n, optr396); } 
		}

		public static unsafe void DeleteQueriesARB(Int32 n, UInt32[] ids)
		{
			fixed (UInt32* ptr397 = &ids[0]) { glDeleteQueriesARB(n, new IntPtr(ptr397)); } 
		}

		public static unsafe bool IsQueryARB(UInt32 id)
		{
			return (glIsQueryARB(id) == 1);
		}

		public static unsafe void BeginQueryARB(GLEnum target, UInt32 id)
		{
			glBeginQueryARB((uint)target, id);
		}

		public static unsafe void EndQueryARB(GLEnum target)
		{
			glEndQueryARB((uint)target);
		}

		public static unsafe void GetQueryivARB(GLEnum target, GLEnum pname, [OutAttribute] Int32[] parameters)
		{
			fixed (Int32* optr398 = parameters) { glGetQueryivARB((uint)target, (uint)pname, optr398); } 
		}

		public static unsafe void GetQueryObjectivARB(UInt32 id, GLEnum pname, [OutAttribute] Int32[] parameters)
		{
			fixed (Int32* optr399 = parameters) { glGetQueryObjectivARB(id, (uint)pname, optr399); } 
		}

		public static unsafe void GetQueryObjectuivARB(UInt32 id, GLEnum pname, [OutAttribute] UInt32[] parameters)
		{
			fixed (UInt32* optr400 = parameters) { glGetQueryObjectuivARB(id, (uint)pname, optr400); } 
		}

		public static unsafe void DeleteObjectARB(UInt32 obj)
		{
			glDeleteObjectARB(obj);
		}

		public static unsafe UInt32 GetHandleARB(GLEnum pname)
		{
			return glGetHandleARB((uint)pname);
		}

		public static unsafe void DetachObjectARB(UInt32 containerObj, UInt32 attachedObj)
		{
			glDetachObjectARB(containerObj, attachedObj);
		}

		public static unsafe UInt32 CreateShaderObjectARB(GLEnum shaderType)
		{
			return glCreateShaderObjectARB((uint)shaderType);
		}

		public static unsafe void ShaderSourceARB(UInt32 shaderObj, Int32 count, IntPtr[] str, Int32[] length)
		{
			fixed (Int32* ptr402 = &length[0]) { fixed (IntPtr* ptr401 = &str[0]) { glShaderSourceARB(shaderObj, count, new IntPtr(ptr401), new IntPtr(ptr402)); }  } 
		}

		public static unsafe void CompileShaderARB(UInt32 shaderObj)
		{
			glCompileShaderARB(shaderObj);
		}

		public static unsafe UInt32 CreateProgramObjectARB()
		{
			return glCreateProgramObjectARB();
		}

		public static unsafe void AttachObjectARB(UInt32 containerObj, UInt32 obj)
		{
			glAttachObjectARB(containerObj, obj);
		}

		public static unsafe void LinkProgramARB(UInt32 programObj)
		{
			glLinkProgramARB(programObj);
		}

		public static unsafe void UseProgramObjectARB(UInt32 programObj)
		{
			glUseProgramObjectARB(programObj);
		}

		public static unsafe void ValidateProgramARB(UInt32 programObj)
		{
			glValidateProgramARB(programObj);
		}

		public static unsafe void Uniform1fARB(Int32 location, float v0)
		{
			glUniform1fARB(location, v0);
		}

		public static unsafe void Uniform2fARB(Int32 location, float v0, float v1)
		{
			glUniform2fARB(location, v0, v1);
		}

		public static unsafe void Uniform3fARB(Int32 location, float v0, float v1, float v2)
		{
			glUniform3fARB(location, v0, v1, v2);
		}

		public static unsafe void Uniform4fARB(Int32 location, float v0, float v1, float v2, float v3)
		{
			glUniform4fARB(location, v0, v1, v2, v3);
		}

		public static unsafe void Uniform1iARB(Int32 location, Int32 v0)
		{
			glUniform1iARB(location, v0);
		}

		public static unsafe void Uniform2iARB(Int32 location, Int32 v0, Int32 v1)
		{
			glUniform2iARB(location, v0, v1);
		}

		public static unsafe void Uniform3iARB(Int32 location, Int32 v0, Int32 v1, Int32 v2)
		{
			glUniform3iARB(location, v0, v1, v2);
		}

		public static unsafe void Uniform4iARB(Int32 location, Int32 v0, Int32 v1, Int32 v2, Int32 v3)
		{
			glUniform4iARB(location, v0, v1, v2, v3);
		}

		public static unsafe void Uniform1fvARB(Int32 location, Int32 count, float[] val)
		{
			fixed (float* ptr403 = &val[0]) { glUniform1fvARB(location, count, new IntPtr(ptr403)); } 
		}

		public static unsafe void Uniform2fvARB(Int32 location, Int32 count, float[] val)
		{
			fixed (float* ptr404 = &val[0]) { glUniform2fvARB(location, count, new IntPtr(ptr404)); } 
		}

		public static unsafe void Uniform3fvARB(Int32 location, Int32 count, float[] val)
		{
			fixed (float* ptr405 = &val[0]) { glUniform3fvARB(location, count, new IntPtr(ptr405)); } 
		}

		public static unsafe void Uniform4fvARB(Int32 location, Int32 count, float[] val)
		{
			fixed (float* ptr406 = &val[0]) { glUniform4fvARB(location, count, new IntPtr(ptr406)); } 
		}

		public static unsafe void Uniform1ivARB(Int32 location, Int32 count, Int32[] val)
		{
			fixed (Int32* ptr407 = &val[0]) { glUniform1ivARB(location, count, new IntPtr(ptr407)); } 
		}

		public static unsafe void Uniform2ivARB(Int32 location, Int32 count, Int32[] val)
		{
			fixed (Int32* ptr408 = &val[0]) { glUniform2ivARB(location, count, new IntPtr(ptr408)); } 
		}

		public static unsafe void Uniform3ivARB(Int32 location, Int32 count, Int32[] val)
		{
			fixed (Int32* ptr409 = &val[0]) { glUniform3ivARB(location, count, new IntPtr(ptr409)); } 
		}

		public static unsafe void Uniform4ivARB(Int32 location, Int32 count, Int32[] val)
		{
			fixed (Int32* ptr410 = &val[0]) { glUniform4ivARB(location, count, new IntPtr(ptr410)); } 
		}

		public static unsafe void UniformMatrix2fvARB(Int32 location, Int32 count, bool transpose, float[] val)
		{
			fixed (float* ptr411 = &val[0]) { glUniformMatrix2fvARB(location, count, transpose ? ((byte)1) : ((byte)0), new IntPtr(ptr411)); } 
		}

		public static unsafe void UniformMatrix3fvARB(Int32 location, Int32 count, bool transpose, float[] val)
		{
			fixed (float* ptr412 = &val[0]) { glUniformMatrix3fvARB(location, count, transpose ? ((byte)1) : ((byte)0), new IntPtr(ptr412)); } 
		}

		public static unsafe void UniformMatrix4fvARB(Int32 location, Int32 count, bool transpose, float[] val)
		{
			fixed (float* ptr413 = &val[0]) { glUniformMatrix4fvARB(location, count, transpose ? ((byte)1) : ((byte)0), new IntPtr(ptr413)); } 
		}

		public static unsafe void GetObjectParameterfvARB(UInt32 obj, GLEnum pname, [OutAttribute] float[] parameters)
		{
			fixed (float* optr414 = parameters) { glGetObjectParameterfvARB(obj, (uint)pname, optr414); } 
		}

		public static unsafe void GetObjectParameterivARB(UInt32 obj, GLEnum pname, [OutAttribute] Int32[] parameters)
		{
			fixed (Int32* optr415 = parameters) { glGetObjectParameterivARB(obj, (uint)pname, optr415); } 
		}

		public static unsafe void GetInfoLogARB(UInt32 obj, Int32 maxLength, [OutAttribute] Int32[] length, [OutAttribute] byte[] infoLog)
		{
			fixed (byte* optr417 = infoLog) { fixed (Int32* optr416 = length) { glGetInfoLogARB(obj, maxLength, optr416, optr417); }  } 
		}

		public static unsafe void GetAttachedObjectsARB(UInt32 containerObj, Int32 maxCount, [OutAttribute] Int32[] count, [OutAttribute] UInt32[] obj)
		{
			fixed (UInt32* optr419 = obj) { fixed (Int32* optr418 = count) { glGetAttachedObjectsARB(containerObj, maxCount, optr418, optr419); }  } 
		}

		public static unsafe Int32 GetUniformLocationARB(UInt32 programObj, byte[] name)
		{
			fixed (byte* ptr420 = &name[0]) { return glGetUniformLocationARB(programObj, new IntPtr(ptr420)); } 
		}

		public static unsafe void GetActiveUniformARB(UInt32 programObj, UInt32 index, Int32 maxLength, [OutAttribute] Int32[] length, [OutAttribute] Int32[] size, [OutAttribute] GLEnum[] type, [OutAttribute] byte[] name)
		{
			fixed (byte* optr424 = name) { uint[] unt423 = new uint[type.Length];
			fixed (uint* ptr423 = unt423) { fixed (Int32* optr422 = size) { fixed (Int32* optr421 = length) { glGetActiveUniformARB(programObj, index, maxLength, optr421, optr422, ptr423, optr424); }  }  } 
			for (int i = 0; i < unt423.Length; i++)
				type[i] = (GLEnum)unt423[i];
			 } 
		}

		public static unsafe void GetUniformfvARB(UInt32 programObj, Int32 location, [OutAttribute] float[] parameters)
		{
			fixed (float* optr425 = parameters) { glGetUniformfvARB(programObj, location, optr425); } 
		}

		public static unsafe void GetUniformivARB(UInt32 programObj, Int32 location, [OutAttribute] Int32[] parameters)
		{
			fixed (Int32* optr426 = parameters) { glGetUniformivARB(programObj, location, optr426); } 
		}

		public static unsafe void GetShaderSourceARB(UInt32 obj, Int32 maxLength, [OutAttribute] Int32[] length, [OutAttribute] byte[] source)
		{
			fixed (byte* optr428 = source) { fixed (Int32* optr427 = length) { glGetShaderSourceARB(obj, maxLength, optr427, optr428); }  } 
		}

		public static unsafe void BindAttribLocationARB(UInt32 programObj, UInt32 index, byte[] name)
		{
			fixed (byte* ptr429 = &name[0]) { glBindAttribLocationARB(programObj, index, new IntPtr(ptr429)); } 
		}

		public static unsafe void GetActiveAttribARB(UInt32 programObj, UInt32 index, Int32 maxLength, [OutAttribute] Int32[] length, [OutAttribute] Int32[] size, [OutAttribute] GLEnum[] type, [OutAttribute] byte[] name)
		{
			fixed (byte* optr433 = name) { uint[] unt432 = new uint[type.Length];
			fixed (uint* ptr432 = unt432) { fixed (Int32* optr431 = size) { fixed (Int32* optr430 = length) { glGetActiveAttribARB(programObj, index, maxLength, optr430, optr431, ptr432, optr433); }  }  } 
			for (int i = 0; i < unt432.Length; i++)
				type[i] = (GLEnum)unt432[i];
			 } 
		}

		public static unsafe Int32 GetAttribLocationARB(UInt32 programObj, byte[] name)
		{
			fixed (byte* ptr434 = &name[0]) { return glGetAttribLocationARB(programObj, new IntPtr(ptr434)); } 
		}

		public static unsafe void DrawBuffersARB(Int32 n, GLEnum[] bufs)
		{
			fixed (GLEnum* ptr435 = &bufs[0]) { glDrawBuffersARB(n, new IntPtr(ptr435)); } 
		}

		public static unsafe void ClampColorARB(GLEnum target, GLEnum clamp)
		{
			glClampColorARB((uint)target, (uint)clamp);
		}

		public static unsafe void DrawArraysInstancedARB(BeginMode mode, Int32 first, Int32 count, Int32 primcount)
		{
			glDrawArraysInstancedARB((uint)mode, first, count, primcount);
		}

		public static unsafe void DrawElementsInstancedARB(BeginMode mode, Int32 count, GLEnum type, IntPtr indices, Int32 primcount)
		{
			glDrawElementsInstancedARB((uint)mode, count, (uint)type, indices, primcount);
		}

		public static unsafe bool IsRenderbuffer(UInt32 renderbuffer)
		{
			return (glIsRenderbuffer(renderbuffer) == 1);
		}

		public static unsafe void BindRenderbuffer(GLEnum target, UInt32 renderbuffer)
		{
			glBindRenderbuffer((uint)target, renderbuffer);
		}

		public static unsafe void DeleteRenderbuffers(Int32 n, UInt32[] renderbuffers)
		{
			fixed (UInt32* ptr436 = &renderbuffers[0]) { glDeleteRenderbuffers(n, new IntPtr(ptr436)); } 
		}

		public static unsafe void GenRenderbuffers(Int32 n, [OutAttribute] UInt32[] renderbuffers)
		{
			fixed (UInt32* optr437 = renderbuffers) { glGenRenderbuffers(n, optr437); } 
		}

		public static unsafe void RenderbufferStorage(GLEnum target, GLEnum internalformat, Int32 width, Int32 height)
		{
			glRenderbufferStorage((uint)target, (uint)internalformat, width, height);
		}

		public static unsafe void GetRenderbufferParameteriv(GLEnum target, GLEnum pname, [OutAttribute] Int32[] parameters)
		{
			fixed (Int32* optr438 = parameters) { glGetRenderbufferParameteriv((uint)target, (uint)pname, optr438); } 
		}

		public static unsafe bool IsFramebuffer(UInt32 framebuffer)
		{
			return (glIsFramebuffer(framebuffer) == 1);
		}

		public static unsafe void BindFramebuffer(GLEnum target, UInt32 framebuffer)
		{
			glBindFramebuffer((uint)target, framebuffer);
		}

		public static unsafe void DeleteFramebuffers(Int32 n, UInt32[] framebuffers)
		{
			fixed (UInt32* ptr439 = &framebuffers[0]) { glDeleteFramebuffers(n, new IntPtr(ptr439)); } 
		}

		public static unsafe void GenFramebuffers(Int32 n, [OutAttribute] UInt32[] framebuffers)
		{
			fixed (UInt32* optr440 = framebuffers) { glGenFramebuffers(n, optr440); } 
		}

		public static unsafe GLEnum CheckFramebufferStatus(GLEnum target)
		{
			return (GLEnum) glCheckFramebufferStatus((uint)target);
		}

		public static unsafe void FramebufferTexture1D(GLEnum target, GLEnum attachment, GLEnum textarget, UInt32 texture, Int32 level)
		{
			glFramebufferTexture1D((uint)target, (uint)attachment, (uint)textarget, texture, level);
		}

		public static unsafe void FramebufferTexture2D(GLEnum target, GLEnum attachment, GLEnum textarget, UInt32 texture, Int32 level)
		{
			glFramebufferTexture2D((uint)target, (uint)attachment, (uint)textarget, texture, level);
		}

		public static unsafe void FramebufferTexture3D(GLEnum target, GLEnum attachment, GLEnum textarget, UInt32 texture, Int32 level, Int32 zoffset)
		{
			glFramebufferTexture3D((uint)target, (uint)attachment, (uint)textarget, texture, level, zoffset);
		}

		public static unsafe void FramebufferRenderbuffer(GLEnum target, GLEnum attachment, GLEnum renderbuffertarget, UInt32 renderbuffer)
		{
			glFramebufferRenderbuffer((uint)target, (uint)attachment, (uint)renderbuffertarget, renderbuffer);
		}

		public static unsafe void GetFramebufferAttachmentParameteriv(GLEnum target, GLEnum attachment, GLEnum pname, [OutAttribute] Int32[] parameters)
		{
			fixed (Int32* optr441 = parameters) { glGetFramebufferAttachmentParameteriv((uint)target, (uint)attachment, (uint)pname, optr441); } 
		}

		public static unsafe void GenerateMipmap(GLEnum target)
		{
			glGenerateMipmap((uint)target);
		}

		public static unsafe void BlitFramebuffer(Int32 srcX0, Int32 srcY0, Int32 srcX1, Int32 srcY1, Int32 dstX0, Int32 dstY0, Int32 dstX1, Int32 dstY1, UInt32 mask, GLEnum filter)
		{
			glBlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, (uint)filter);
		}

		public static unsafe void RenderbufferStorageMultisample(GLEnum target, Int32 samples, GLEnum internalformat, Int32 width, Int32 height)
		{
			glRenderbufferStorageMultisample((uint)target, samples, (uint)internalformat, width, height);
		}

		public static unsafe void FramebufferTextureLayer(GLEnum target, GLEnum attachment, UInt32 texture, Int32 level, Int32 layer)
		{
			glFramebufferTextureLayer((uint)target, (uint)attachment, texture, level, layer);
		}

		public static unsafe void ProgramParameteriARB(UInt32 program, GLEnum pname, Int32 val)
		{
			glProgramParameteriARB(program, (uint)pname, val);
		}

		public static unsafe void FramebufferTextureARB(GLEnum target, GLEnum attachment, UInt32 texture, Int32 level)
		{
			glFramebufferTextureARB((uint)target, (uint)attachment, texture, level);
		}

		public static unsafe void FramebufferTextureLayerARB(GLEnum target, GLEnum attachment, UInt32 texture, Int32 level, Int32 layer)
		{
			glFramebufferTextureLayerARB((uint)target, (uint)attachment, texture, level, layer);
		}

		public static unsafe void FramebufferTextureFaceARB(GLEnum target, GLEnum attachment, UInt32 texture, Int32 level, TextureTarget face)
		{
			glFramebufferTextureFaceARB((uint)target, (uint)attachment, texture, level, (uint)face);
		}

		public static unsafe void VertexAttribDivisorARB(UInt32 index, UInt32 divisor)
		{
			glVertexAttribDivisorARB(index, divisor);
		}

		public static unsafe IntPtr MapBufferRange(GLEnum target, IntPtr offset, IntPtr length, UInt32 access)
		{
			return glMapBufferRange((uint)target, offset, length, access);
		}

		public static unsafe void FlushMappedBufferRange(GLEnum target, IntPtr offset, IntPtr length)
		{
			glFlushMappedBufferRange((uint)target, offset, length);
		}

		public static unsafe void TexBufferARB(TextureTarget target, GLEnum internalformat, UInt32 buffer)
		{
			glTexBufferARB((uint)target, (uint)internalformat, buffer);
		}

		public static unsafe void BindVertexArray(UInt32 array)
		{
			glBindVertexArray(array);
		}

		public static unsafe void DeleteVertexArrays(Int32 n, UInt32[] arrays)
		{
			fixed (UInt32* ptr442 = &arrays[0]) { glDeleteVertexArrays(n, new IntPtr(ptr442)); } 
		}

		public static unsafe void GenVertexArrays(Int32 n, [OutAttribute] UInt32[] arrays)
		{
			fixed (UInt32* optr443 = arrays) { glGenVertexArrays(n, optr443); } 
		}

		public static unsafe bool IsVertexArray(UInt32 array)
		{
			return (glIsVertexArray(array) == 1);
		}

		public static unsafe void GetUniformIndices(UInt32 program, Int32 uniformCount, IntPtr[] uniformNames, [OutAttribute] UInt32[] uniformIndices)
		{
			fixed (UInt32* optr445 = uniformIndices) { fixed (IntPtr* ptr444 = &uniformNames[0]) { glGetUniformIndices(program, uniformCount, new IntPtr(ptr444), optr445); }  } 
		}

		public static unsafe void GetActiveUniformsiv(UInt32 program, Int32 uniformCount, UInt32[] uniformIndices, GLEnum pname, [OutAttribute] Int32[] parameters)
		{
			fixed (Int32* optr447 = parameters) { fixed (UInt32* ptr446 = &uniformIndices[0]) { glGetActiveUniformsiv(program, uniformCount, new IntPtr(ptr446), (uint)pname, optr447); }  } 
		}

		public static unsafe void GetActiveUniformName(UInt32 program, UInt32 uniformIndex, Int32 bufSize, [OutAttribute] Int32[] length, [OutAttribute] byte[] uniformName)
		{
			fixed (byte* optr449 = uniformName) { fixed (Int32* optr448 = length) { glGetActiveUniformName(program, uniformIndex, bufSize, optr448, optr449); }  } 
		}

		public static unsafe UInt32 GetUniformBlockIndex(UInt32 program, byte[] uniformBlockName)
		{
			fixed (byte* ptr450 = &uniformBlockName[0]) { return glGetUniformBlockIndex(program, new IntPtr(ptr450)); } 
		}

		public static unsafe void GetActiveUniformBlockiv(UInt32 program, UInt32 uniformBlockIndex, GLEnum pname, [OutAttribute] Int32[] parameters)
		{
			fixed (Int32* optr451 = parameters) { glGetActiveUniformBlockiv(program, uniformBlockIndex, (uint)pname, optr451); } 
		}

		public static unsafe void GetActiveUniformBlockName(UInt32 program, UInt32 uniformBlockIndex, Int32 bufSize, [OutAttribute] Int32[] length, [OutAttribute] byte[] uniformBlockName)
		{
			fixed (byte* optr453 = uniformBlockName) { fixed (Int32* optr452 = length) { glGetActiveUniformBlockName(program, uniformBlockIndex, bufSize, optr452, optr453); }  } 
		}

		public static unsafe void UniformBlockBinding(UInt32 program, UInt32 uniformBlockIndex, UInt32 uniformBlockBinding)
		{
			glUniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding);
		}

		public static unsafe void CopyBufferSubData(GLEnum readTarget, GLEnum writeTarget, IntPtr readOffset, IntPtr writeOffset, IntPtr size)
		{
			glCopyBufferSubData((uint)readTarget, (uint)writeTarget, readOffset, writeOffset, size);
		}

		public static unsafe void DrawElementsBaseVertex(GLEnum mode, Int32 count, GLEnum type, IntPtr indices, Int32 basevertex)
		{
			glDrawElementsBaseVertex((uint)mode, count, (uint)type, indices, basevertex);
		}

		public static unsafe void DrawRangeElementsBaseVertex(GLEnum mode, UInt32 start, UInt32 end, Int32 count, GLEnum type, IntPtr indices, Int32 basevertex)
		{
			glDrawRangeElementsBaseVertex((uint)mode, start, end, count, (uint)type, indices, basevertex);
		}

		public static unsafe void DrawElementsInstancedBaseVertex(GLEnum mode, Int32 count, GLEnum type, IntPtr indices, Int32 primcount, Int32 basevertex)
		{
			glDrawElementsInstancedBaseVertex((uint)mode, count, (uint)type, indices, primcount, basevertex);
		}

		public static unsafe void MultiDrawElementsBaseVertex(GLEnum mode, Int32[] count, GLEnum type, IntPtr[] indices, Int32 primcount, Int32[] basevertex)
		{
			fixed (Int32* ptr456 = &basevertex[0]) { fixed (IntPtr* ptr455 = &indices[0]) { fixed (Int32* ptr454 = &count[0]) { glMultiDrawElementsBaseVertex((uint)mode, new IntPtr(ptr454), (uint)type, new IntPtr(ptr455), primcount, new IntPtr(ptr456)); }  }  } 
		}

		public static unsafe void ProvokingVertex(GLEnum mode)
		{
			glProvokingVertex((uint)mode);
		}

		public static unsafe IntPtr FenceSync(GLEnum condition, UInt32 flags)
		{
			return glFenceSync((uint)condition, flags);
		}

		public static unsafe bool IsSync(IntPtr sync)
		{
			return (glIsSync(sync) == 1);
		}

		public static unsafe void DeleteSync(IntPtr sync)
		{
			glDeleteSync(sync);
		}

		public static unsafe GLEnum ClientWaitSync(IntPtr sync, UInt32 flags, UInt64 timeout)
		{
			return (GLEnum) glClientWaitSync(sync, flags, timeout);
		}

		public static unsafe void WaitSync(IntPtr sync, UInt32 flags, UInt64 timeout)
		{
			glWaitSync(sync, flags, timeout);
		}

		public static unsafe void GetInteger64v(GLEnum pname, [OutAttribute] Int64[] parameters)
		{
			fixed (Int64* optr457 = parameters) { glGetInteger64v((uint)pname, optr457); } 
		}

		public static unsafe void GetSynciv(IntPtr sync, GLEnum pname, Int32 bufSize, [OutAttribute] Int32[] length, [OutAttribute] Int32[] values)
		{
			fixed (Int32* optr459 = values) { fixed (Int32* optr458 = length) { glGetSynciv(sync, (uint)pname, bufSize, optr458, optr459); }  } 
		}

		public static unsafe void TexImage2DMultisample(GLEnum target, Int32 samples, Int32 internalformat, Int32 width, Int32 height, bool fixedsamplelocations)
		{
			glTexImage2DMultisample((uint)target, samples, internalformat, width, height, fixedsamplelocations ? ((byte)1) : ((byte)0));
		}

		public static unsafe void TexImage3DMultisample(GLEnum target, Int32 samples, Int32 internalformat, Int32 width, Int32 height, Int32 depth, bool fixedsamplelocations)
		{
			glTexImage3DMultisample((uint)target, samples, internalformat, width, height, depth, fixedsamplelocations ? ((byte)1) : ((byte)0));
		}

		public static unsafe void GetMultisamplefv(GLEnum pname, UInt32 index, [OutAttribute] float[] val)
		{
			fixed (float* optr460 = val) { glGetMultisamplefv((uint)pname, index, optr460); } 
		}

		public static unsafe void SampleMask(UInt32 index, UInt32 mask)
		{
			glSampleMaski(index, mask);
		}

		public static unsafe void BlendEquation(UInt32 buf, GLEnum mode)
		{
			glBlendEquationi(buf, (uint)mode);
		}

		public static unsafe void BlendEquationSeparate(UInt32 buf, GLEnum modeRGB, GLEnum modeAlpha)
		{
			glBlendEquationSeparatei(buf, (uint)modeRGB, (uint)modeAlpha);
		}

		public static unsafe void BlendFunci(UInt32 buf, GLEnum src, GLEnum dst)
		{
			glBlendFunci(buf, (uint)src, (uint)dst);
		}

		public static unsafe void BlendFuncSeparate(UInt32 buf, GLEnum srcRGB, GLEnum dstRGB, GLEnum srcAlpha, GLEnum dstAlpha)
		{
			glBlendFuncSeparatei(buf, (uint)srcRGB, (uint)dstRGB, (uint)srcAlpha, (uint)dstAlpha);
		}

		public static unsafe void MinSampleShading(float val)
		{
			glMinSampleShading(val);
		}

		public static unsafe void NamedStringARB(GLEnum type, Int32 namelen, byte[] name, Int32 stringlen, byte[] str)
		{
			fixed (byte* ptr462 = &str[0]) { fixed (byte* ptr461 = &name[0]) { glNamedStringARB((uint)type, namelen, new IntPtr(ptr461), stringlen, new IntPtr(ptr462)); }  } 
		}

		public static unsafe void DeleteNamedStringARB(Int32 namelen, byte[] name)
		{
			fixed (byte* ptr463 = &name[0]) { glDeleteNamedStringARB(namelen, new IntPtr(ptr463)); } 
		}

		public static unsafe void CompileShaderIncludeARB(UInt32 shader, Int32 count, IntPtr[] path, Int32[] length)
		{
			fixed (Int32* ptr465 = &length[0]) { fixed (IntPtr* ptr464 = &path[0]) { glCompileShaderIncludeARB(shader, count, new IntPtr(ptr464), new IntPtr(ptr465)); }  } 
		}

		public static unsafe bool IsNamedStringARB(Int32 namelen, byte[] name)
		{
			fixed (byte* ptr466 = &name[0]) { return (glIsNamedStringARB(namelen, new IntPtr(ptr466)) == 1); } 
		}

		public static unsafe void GetNamedStringARB(Int32 namelen, byte[] name, Int32 bufSize, [OutAttribute] Int32[] stringlen, [OutAttribute] byte[] str)
		{
			fixed (byte* optr469 = str) { fixed (Int32* optr468 = stringlen) { fixed (byte* ptr467 = &name[0]) { glGetNamedStringARB(namelen, new IntPtr(ptr467), bufSize, optr468, optr469); }  }  } 
		}

		public static unsafe void GetNamedStringivARB(Int32 namelen, byte[] name, GLEnum pname, [OutAttribute] Int32[] parameters)
		{
			fixed (Int32* optr471 = parameters) { fixed (byte* ptr470 = &name[0]) { glGetNamedStringivARB(namelen, new IntPtr(ptr470), (uint)pname, optr471); }  } 
		}

		public static unsafe void BindFragDataLocationIndexed(UInt32 program, UInt32 colorNumber, UInt32 index, byte[] name)
		{
			fixed (byte* ptr472 = &name[0]) { glBindFragDataLocationIndexed(program, colorNumber, index, new IntPtr(ptr472)); } 
		}

		public static unsafe Int32 GetFragDataIndex(UInt32 program, byte[] name)
		{
			fixed (byte* ptr473 = &name[0]) { return glGetFragDataIndex(program, new IntPtr(ptr473)); } 
		}

		public static unsafe void GenSamplers(Int32 count, [OutAttribute] UInt32[] samplers)
		{
			fixed (UInt32* optr474 = samplers) { glGenSamplers(count, optr474); } 
		}

		public static unsafe void DeleteSamplers(Int32 count, UInt32[] samplers)
		{
			fixed (UInt32* ptr475 = &samplers[0]) { glDeleteSamplers(count, new IntPtr(ptr475)); } 
		}

		public static unsafe bool IsSampler(UInt32 sampler)
		{
			return (glIsSampler(sampler) == 1);
		}

		public static unsafe void BindSampler(UInt32 unit, UInt32 sampler)
		{
			glBindSampler(unit, sampler);
		}

		public static unsafe void SamplerParameteri(UInt32 sampler, GLEnum pname, Int32 param)
		{
			glSamplerParameteri(sampler, (uint)pname, param);
		}

		public static unsafe void SamplerParameteriv(UInt32 sampler, GLEnum pname, Int32[] param)
		{
			fixed (Int32* ptr476 = &param[0]) { glSamplerParameteriv(sampler, (uint)pname, new IntPtr(ptr476)); } 
		}

		public static unsafe void SamplerParameterf(UInt32 sampler, GLEnum pname, float param)
		{
			glSamplerParameterf(sampler, (uint)pname, param);
		}

		public static unsafe void SamplerParameterfv(UInt32 sampler, GLEnum pname, float[] param)
		{
			fixed (float* ptr477 = &param[0]) { glSamplerParameterfv(sampler, (uint)pname, new IntPtr(ptr477)); } 
		}

		public static unsafe void SamplerParameterIiv(UInt32 sampler, GLEnum pname, Int32[] param)
		{
			fixed (Int32* ptr478 = &param[0]) { glSamplerParameterIiv(sampler, (uint)pname, new IntPtr(ptr478)); } 
		}

		public static unsafe void SamplerParameterIuiv(UInt32 sampler, GLEnum pname, UInt32[] param)
		{
			fixed (UInt32* ptr479 = &param[0]) { glSamplerParameterIuiv(sampler, (uint)pname, new IntPtr(ptr479)); } 
		}

		public static unsafe void GetSamplerParameteriv(UInt32 sampler, GLEnum pname, [OutAttribute] Int32[] parameters)
		{
			fixed (Int32* optr480 = parameters) { glGetSamplerParameteriv(sampler, (uint)pname, optr480); } 
		}

		public static unsafe void GetSamplerParameterIiv(UInt32 sampler, GLEnum pname, [OutAttribute] Int32[] parameters)
		{
			fixed (Int32* optr481 = parameters) { glGetSamplerParameterIiv(sampler, (uint)pname, optr481); } 
		}

		public static unsafe void GetSamplerParameterfv(UInt32 sampler, GLEnum pname, [OutAttribute] float[] parameters)
		{
			fixed (float* optr482 = parameters) { glGetSamplerParameterfv(sampler, (uint)pname, optr482); } 
		}

		public static unsafe void GetSamplerParameterIfv(UInt32 sampler, GLEnum pname, [OutAttribute] float[] parameters)
		{
			fixed (float* optr483 = parameters) { glGetSamplerParameterIfv(sampler, (uint)pname, optr483); } 
		}

		public static unsafe void QueryCounter(UInt32 id, GLEnum target)
		{
			glQueryCounter(id, (uint)target);
		}

		public static unsafe void GetQueryObjecti64v(UInt32 id, GLEnum pname, [OutAttribute] Int64[] parameters)
		{
			fixed (Int64* optr484 = parameters) { glGetQueryObjecti64v(id, (uint)pname, optr484); } 
		}

		public static unsafe void GetQueryObjectui64v(UInt32 id, GLEnum pname, [OutAttribute] UInt64[] parameters)
		{
			fixed (UInt64* optr485 = parameters) { glGetQueryObjectui64v(id, (uint)pname, optr485); } 
		}

		public static unsafe void VertexP2ui(GLEnum type, UInt32 val)
		{
			glVertexP2ui((uint)type, val);
		}

		public static unsafe void VertexP2uiv(GLEnum type, UInt32[] val)
		{
			fixed (UInt32* ptr486 = &val[0]) { glVertexP2uiv((uint)type, new IntPtr(ptr486)); } 
		}

		public static unsafe void VertexP3ui(GLEnum type, UInt32 val)
		{
			glVertexP3ui((uint)type, val);
		}

		public static unsafe void VertexP3uiv(GLEnum type, UInt32[] val)
		{
			fixed (UInt32* ptr487 = &val[0]) { glVertexP3uiv((uint)type, new IntPtr(ptr487)); } 
		}

		public static unsafe void VertexP4ui(GLEnum type, UInt32 val)
		{
			glVertexP4ui((uint)type, val);
		}

		public static unsafe void VertexP4uiv(GLEnum type, UInt32[] val)
		{
			fixed (UInt32* ptr488 = &val[0]) { glVertexP4uiv((uint)type, new IntPtr(ptr488)); } 
		}

		public static unsafe void TexCoordP1ui(GLEnum type, UInt32 coords)
		{
			glTexCoordP1ui((uint)type, coords);
		}

		public static unsafe void TexCoordP1uiv(GLEnum type, UInt32[] coords)
		{
			fixed (UInt32* ptr489 = &coords[0]) { glTexCoordP1uiv((uint)type, new IntPtr(ptr489)); } 
		}

		public static unsafe void TexCoordP2ui(GLEnum type, UInt32 coords)
		{
			glTexCoordP2ui((uint)type, coords);
		}

		public static unsafe void TexCoordP2uiv(GLEnum type, UInt32[] coords)
		{
			fixed (UInt32* ptr490 = &coords[0]) { glTexCoordP2uiv((uint)type, new IntPtr(ptr490)); } 
		}

		public static unsafe void TexCoordP3ui(GLEnum type, UInt32 coords)
		{
			glTexCoordP3ui((uint)type, coords);
		}

		public static unsafe void TexCoordP3uiv(GLEnum type, UInt32[] coords)
		{
			fixed (UInt32* ptr491 = &coords[0]) { glTexCoordP3uiv((uint)type, new IntPtr(ptr491)); } 
		}

		public static unsafe void TexCoordP4ui(GLEnum type, UInt32 coords)
		{
			glTexCoordP4ui((uint)type, coords);
		}

		public static unsafe void TexCoordP4uiv(GLEnum type, UInt32[] coords)
		{
			fixed (UInt32* ptr492 = &coords[0]) { glTexCoordP4uiv((uint)type, new IntPtr(ptr492)); } 
		}

		public static unsafe void MultiTexCoordP1ui(GLEnum texture, GLEnum type, UInt32 coords)
		{
			glMultiTexCoordP1ui((uint)texture, (uint)type, coords);
		}

		public static unsafe void MultiTexCoordP1uiv(GLEnum texture, GLEnum type, UInt32[] coords)
		{
			fixed (UInt32* ptr493 = &coords[0]) { glMultiTexCoordP1uiv((uint)texture, (uint)type, new IntPtr(ptr493)); } 
		}

		public static unsafe void MultiTexCoordP2ui(GLEnum texture, GLEnum type, UInt32 coords)
		{
			glMultiTexCoordP2ui((uint)texture, (uint)type, coords);
		}

		public static unsafe void MultiTexCoordP2uiv(GLEnum texture, GLEnum type, UInt32[] coords)
		{
			fixed (UInt32* ptr494 = &coords[0]) { glMultiTexCoordP2uiv((uint)texture, (uint)type, new IntPtr(ptr494)); } 
		}

		public static unsafe void MultiTexCoordP3ui(GLEnum texture, GLEnum type, UInt32 coords)
		{
			glMultiTexCoordP3ui((uint)texture, (uint)type, coords);
		}

		public static unsafe void MultiTexCoordP3uiv(GLEnum texture, GLEnum type, UInt32[] coords)
		{
			fixed (UInt32* ptr495 = &coords[0]) { glMultiTexCoordP3uiv((uint)texture, (uint)type, new IntPtr(ptr495)); } 
		}

		public static unsafe void MultiTexCoordP4ui(GLEnum texture, GLEnum type, UInt32 coords)
		{
			glMultiTexCoordP4ui((uint)texture, (uint)type, coords);
		}

		public static unsafe void MultiTexCoordP4uiv(GLEnum texture, GLEnum type, UInt32[] coords)
		{
			fixed (UInt32* ptr496 = &coords[0]) { glMultiTexCoordP4uiv((uint)texture, (uint)type, new IntPtr(ptr496)); } 
		}

		public static unsafe void NormalP3ui(GLEnum type, UInt32 coords)
		{
			glNormalP3ui((uint)type, coords);
		}

		public static unsafe void NormalP3uiv(GLEnum type, UInt32[] coords)
		{
			fixed (UInt32* ptr497 = &coords[0]) { glNormalP3uiv((uint)type, new IntPtr(ptr497)); } 
		}

		public static unsafe void ColorP3(GLEnum type, UInt32 color)
		{
			glColorP3ui((uint)type, color);
		}

		public static unsafe void ColorP3(GLEnum type, UInt32[] color)
		{
			fixed (UInt32* ptr498 = &color[0]) { glColorP3uiv((uint)type, new IntPtr(ptr498)); } 
		}

		public static unsafe void ColorP4(GLEnum type, UInt32 color)
		{
			glColorP4ui((uint)type, color);
		}

		public static unsafe void ColorP4(GLEnum type, UInt32[] color)
		{
			fixed (UInt32* ptr499 = &color[0]) { glColorP4uiv((uint)type, new IntPtr(ptr499)); } 
		}

		public static unsafe void SecondaryColorP3ui(GLEnum type, UInt32 color)
		{
			glSecondaryColorP3ui((uint)type, color);
		}

		public static unsafe void SecondaryColorP3uiv(GLEnum type, UInt32[] color)
		{
			fixed (UInt32* ptr500 = &color[0]) { glSecondaryColorP3uiv((uint)type, new IntPtr(ptr500)); } 
		}

		public static unsafe void VertexAttribP1ui(UInt32 index, GLEnum type, bool normalized, UInt32 val)
		{
			glVertexAttribP1ui(index, (uint)type, normalized ? ((byte)1) : ((byte)0), val);
		}

		public static unsafe void VertexAttribP1uiv(UInt32 index, GLEnum type, bool normalized, UInt32[] val)
		{
			fixed (UInt32* ptr501 = &val[0]) { glVertexAttribP1uiv(index, (uint)type, normalized ? ((byte)1) : ((byte)0), new IntPtr(ptr501)); } 
		}

		public static unsafe void VertexAttribP2ui(UInt32 index, GLEnum type, bool normalized, UInt32 val)
		{
			glVertexAttribP2ui(index, (uint)type, normalized ? ((byte)1) : ((byte)0), val);
		}

		public static unsafe void VertexAttribP2uiv(UInt32 index, GLEnum type, bool normalized, UInt32[] val)
		{
			fixed (UInt32* ptr502 = &val[0]) { glVertexAttribP2uiv(index, (uint)type, normalized ? ((byte)1) : ((byte)0), new IntPtr(ptr502)); } 
		}

		public static unsafe void VertexAttribP3ui(UInt32 index, GLEnum type, bool normalized, UInt32 val)
		{
			glVertexAttribP3ui(index, (uint)type, normalized ? ((byte)1) : ((byte)0), val);
		}

		public static unsafe void VertexAttribP3uiv(UInt32 index, GLEnum type, bool normalized, UInt32[] val)
		{
			fixed (UInt32* ptr503 = &val[0]) { glVertexAttribP3uiv(index, (uint)type, normalized ? ((byte)1) : ((byte)0), new IntPtr(ptr503)); } 
		}

		public static unsafe void VertexAttribP4ui(UInt32 index, GLEnum type, bool normalized, UInt32 val)
		{
			glVertexAttribP4ui(index, (uint)type, normalized ? ((byte)1) : ((byte)0), val);
		}

		public static unsafe void VertexAttribP4uiv(UInt32 index, GLEnum type, bool normalized, UInt32[] val)
		{
			fixed (UInt32* ptr504 = &val[0]) { glVertexAttribP4uiv(index, (uint)type, normalized ? ((byte)1) : ((byte)0), new IntPtr(ptr504)); } 
		}

		public static unsafe void DrawArraysIndirect(GLEnum mode, IntPtr indirect)
		{
			glDrawArraysIndirect((uint)mode, indirect);
		}

		public static unsafe void DrawElementsIndirect(GLEnum mode, GLEnum type, IntPtr indirect)
		{
			glDrawElementsIndirect((uint)mode, (uint)type, indirect);
		}

		public static unsafe void Uniform1(Int32 location, double x)
		{
			glUniform1d(location, x);
		}

		public static unsafe void Uniform2(Int32 location, double x, double y)
		{
			glUniform2d(location, x, y);
		}

		public static unsafe void Uniform3(Int32 location, double x, double y, double z)
		{
			glUniform3d(location, x, y, z);
		}

		public static unsafe void Uniform4(Int32 location, double x, double y, double z, double w)
		{
			glUniform4d(location, x, y, z, w);
		}

		public static unsafe void Uniform1(Int32 location, Int32 count, double[] val)
		{
			fixed (double* ptr505 = &val[0]) { glUniform1dv(location, count, new IntPtr(ptr505)); } 
		}

		public static unsafe void Uniform2(Int32 location, Int32 count, double[] val)
		{
			fixed (double* ptr506 = &val[0]) { glUniform2dv(location, count, new IntPtr(ptr506)); } 
		}

		public static unsafe void Uniform3(Int32 location, Int32 count, double[] val)
		{
			fixed (double* ptr507 = &val[0]) { glUniform3dv(location, count, new IntPtr(ptr507)); } 
		}

		public static unsafe void Uniform4(Int32 location, Int32 count, double[] val)
		{
			fixed (double* ptr508 = &val[0]) { glUniform4dv(location, count, new IntPtr(ptr508)); } 
		}

		public static unsafe void UniformMatrix2(Int32 location, Int32 count, bool transpose, double[] val)
		{
			fixed (double* ptr509 = &val[0]) { glUniformMatrix2dv(location, count, transpose ? ((byte)1) : ((byte)0), new IntPtr(ptr509)); } 
		}

		public static unsafe void UniformMatrix3(Int32 location, Int32 count, bool transpose, double[] val)
		{
			fixed (double* ptr510 = &val[0]) { glUniformMatrix3dv(location, count, transpose ? ((byte)1) : ((byte)0), new IntPtr(ptr510)); } 
		}

		public static unsafe void UniformMatrix4(Int32 location, Int32 count, bool transpose, double[] val)
		{
			fixed (double* ptr511 = &val[0]) { glUniformMatrix4dv(location, count, transpose ? ((byte)1) : ((byte)0), new IntPtr(ptr511)); } 
		}

		public static unsafe void UniformMatrix2x3dv(Int32 location, Int32 count, bool transpose, double[] val)
		{
			fixed (double* ptr512 = &val[0]) { glUniformMatrix2x3dv(location, count, transpose ? ((byte)1) : ((byte)0), new IntPtr(ptr512)); } 
		}

		public static unsafe void UniformMatrix2x4dv(Int32 location, Int32 count, bool transpose, double[] val)
		{
			fixed (double* ptr513 = &val[0]) { glUniformMatrix2x4dv(location, count, transpose ? ((byte)1) : ((byte)0), new IntPtr(ptr513)); } 
		}

		public static unsafe void UniformMatrix3x2dv(Int32 location, Int32 count, bool transpose, double[] val)
		{
			fixed (double* ptr514 = &val[0]) { glUniformMatrix3x2dv(location, count, transpose ? ((byte)1) : ((byte)0), new IntPtr(ptr514)); } 
		}

		public static unsafe void UniformMatrix3x4dv(Int32 location, Int32 count, bool transpose, double[] val)
		{
			fixed (double* ptr515 = &val[0]) { glUniformMatrix3x4dv(location, count, transpose ? ((byte)1) : ((byte)0), new IntPtr(ptr515)); } 
		}

		public static unsafe void UniformMatrix4x2dv(Int32 location, Int32 count, bool transpose, double[] val)
		{
			fixed (double* ptr516 = &val[0]) { glUniformMatrix4x2dv(location, count, transpose ? ((byte)1) : ((byte)0), new IntPtr(ptr516)); } 
		}

		public static unsafe void UniformMatrix4x3dv(Int32 location, Int32 count, bool transpose, double[] val)
		{
			fixed (double* ptr517 = &val[0]) { glUniformMatrix4x3dv(location, count, transpose ? ((byte)1) : ((byte)0), new IntPtr(ptr517)); } 
		}

		public static unsafe void GetUniformdv(UInt32 program, Int32 location, [OutAttribute] double[] parameters)
		{
			fixed (double* optr518 = parameters) { glGetUniformdv(program, location, optr518); } 
		}

		public static unsafe void ProgramUniform1dEXT(UInt32 program, Int32 location, double x)
		{
			glProgramUniform1dEXT(program, location, x);
		}

		public static unsafe void ProgramUniform2dEXT(UInt32 program, Int32 location, double x, double y)
		{
			glProgramUniform2dEXT(program, location, x, y);
		}

		public static unsafe void ProgramUniform3dEXT(UInt32 program, Int32 location, double x, double y, double z)
		{
			glProgramUniform3dEXT(program, location, x, y, z);
		}

		public static unsafe void ProgramUniform4dEXT(UInt32 program, Int32 location, double x, double y, double z, double w)
		{
			glProgramUniform4dEXT(program, location, x, y, z, w);
		}

		public static unsafe void ProgramUniform1dvEXT(UInt32 program, Int32 location, Int32 count, double[] val)
		{
			fixed (double* ptr519 = &val[0]) { glProgramUniform1dvEXT(program, location, count, new IntPtr(ptr519)); } 
		}

		public static unsafe void ProgramUniform2dvEXT(UInt32 program, Int32 location, Int32 count, double[] val)
		{
			fixed (double* ptr520 = &val[0]) { glProgramUniform2dvEXT(program, location, count, new IntPtr(ptr520)); } 
		}

		public static unsafe void ProgramUniform3dvEXT(UInt32 program, Int32 location, Int32 count, double[] val)
		{
			fixed (double* ptr521 = &val[0]) { glProgramUniform3dvEXT(program, location, count, new IntPtr(ptr521)); } 
		}

		public static unsafe void ProgramUniform4dvEXT(UInt32 program, Int32 location, Int32 count, double[] val)
		{
			fixed (double* ptr522 = &val[0]) { glProgramUniform4dvEXT(program, location, count, new IntPtr(ptr522)); } 
		}

		public static unsafe void ProgramUniformMatrix2dvEXT(UInt32 program, Int32 location, Int32 count, bool transpose, double[] val)
		{
			fixed (double* ptr523 = &val[0]) { glProgramUniformMatrix2dvEXT(program, location, count, transpose ? ((byte)1) : ((byte)0), new IntPtr(ptr523)); } 
		}

		public static unsafe void ProgramUniformMatrix3dvEXT(UInt32 program, Int32 location, Int32 count, bool transpose, double[] val)
		{
			fixed (double* ptr524 = &val[0]) { glProgramUniformMatrix3dvEXT(program, location, count, transpose ? ((byte)1) : ((byte)0), new IntPtr(ptr524)); } 
		}

		public static unsafe void ProgramUniformMatrix4dvEXT(UInt32 program, Int32 location, Int32 count, bool transpose, double[] val)
		{
			fixed (double* ptr525 = &val[0]) { glProgramUniformMatrix4dvEXT(program, location, count, transpose ? ((byte)1) : ((byte)0), new IntPtr(ptr525)); } 
		}

		public static unsafe void ProgramUniformMatrix2x3dvEXT(UInt32 program, Int32 location, Int32 count, bool transpose, double[] val)
		{
			fixed (double* ptr526 = &val[0]) { glProgramUniformMatrix2x3dvEXT(program, location, count, transpose ? ((byte)1) : ((byte)0), new IntPtr(ptr526)); } 
		}

		public static unsafe void ProgramUniformMatrix2x4dvEXT(UInt32 program, Int32 location, Int32 count, bool transpose, double[] val)
		{
			fixed (double* ptr527 = &val[0]) { glProgramUniformMatrix2x4dvEXT(program, location, count, transpose ? ((byte)1) : ((byte)0), new IntPtr(ptr527)); } 
		}

		public static unsafe void ProgramUniformMatrix3x2dvEXT(UInt32 program, Int32 location, Int32 count, bool transpose, double[] val)
		{
			fixed (double* ptr528 = &val[0]) { glProgramUniformMatrix3x2dvEXT(program, location, count, transpose ? ((byte)1) : ((byte)0), new IntPtr(ptr528)); } 
		}

		public static unsafe void ProgramUniformMatrix3x4dvEXT(UInt32 program, Int32 location, Int32 count, bool transpose, double[] val)
		{
			fixed (double* ptr529 = &val[0]) { glProgramUniformMatrix3x4dvEXT(program, location, count, transpose ? ((byte)1) : ((byte)0), new IntPtr(ptr529)); } 
		}

		public static unsafe void ProgramUniformMatrix4x2dvEXT(UInt32 program, Int32 location, Int32 count, bool transpose, double[] val)
		{
			fixed (double* ptr530 = &val[0]) { glProgramUniformMatrix4x2dvEXT(program, location, count, transpose ? ((byte)1) : ((byte)0), new IntPtr(ptr530)); } 
		}

		public static unsafe void ProgramUniformMatrix4x3dvEXT(UInt32 program, Int32 location, Int32 count, bool transpose, double[] val)
		{
			fixed (double* ptr531 = &val[0]) { glProgramUniformMatrix4x3dvEXT(program, location, count, transpose ? ((byte)1) : ((byte)0), new IntPtr(ptr531)); } 
		}

		public static unsafe Int32 GetSubroutineUniformLocation(UInt32 program, GLEnum shadertype, byte[] name)
		{
			fixed (byte* ptr532 = &name[0]) { return glGetSubroutineUniformLocation(program, (uint)shadertype, new IntPtr(ptr532)); } 
		}

		public static unsafe UInt32 GetSubroutineIndex(UInt32 program, GLEnum shadertype, byte[] name)
		{
			fixed (byte* ptr533 = &name[0]) { return glGetSubroutineIndex(program, (uint)shadertype, new IntPtr(ptr533)); } 
		}

		public static unsafe void GetActiveSubroutineUniformiv(UInt32 program, GLEnum shadertype, UInt32 index, GLEnum pname, [OutAttribute] Int32[] values)
		{
			fixed (Int32* optr534 = values) { glGetActiveSubroutineUniformiv(program, (uint)shadertype, index, (uint)pname, optr534); } 
		}

		public static unsafe void GetActiveSubroutineUniformName(UInt32 program, GLEnum shadertype, UInt32 index, Int32 bufsize, [OutAttribute] Int32[] length, [OutAttribute] byte[] name)
		{
			fixed (byte* optr536 = name) { fixed (Int32* optr535 = length) { glGetActiveSubroutineUniformName(program, (uint)shadertype, index, bufsize, optr535, optr536); }  } 
		}

		public static unsafe void GetActiveSubroutineName(UInt32 program, GLEnum shadertype, UInt32 index, Int32 bufsize, [OutAttribute] Int32[] length, [OutAttribute] byte[] name)
		{
			fixed (byte* optr538 = name) { fixed (Int32* optr537 = length) { glGetActiveSubroutineName(program, (uint)shadertype, index, bufsize, optr537, optr538); }  } 
		}

		public static unsafe void UniformSubroutinesuiv(GLEnum shadertype, Int32 count, UInt32[] indices)
		{
			fixed (UInt32* ptr539 = &indices[0]) { glUniformSubroutinesuiv((uint)shadertype, count, new IntPtr(ptr539)); } 
		}

		public static unsafe void GetUniformSubroutineuiv(GLEnum shadertype, Int32 location, [OutAttribute] UInt32[] parameters)
		{
			fixed (UInt32* optr540 = parameters) { glGetUniformSubroutineuiv((uint)shadertype, location, optr540); } 
		}

		public static unsafe void GetProgramStageiv(UInt32 program, GLEnum shadertype, GLEnum pname, [OutAttribute] Int32[] values)
		{
			fixed (Int32* optr541 = values) { glGetProgramStageiv(program, (uint)shadertype, (uint)pname, optr541); } 
		}

		public static unsafe void PatchParameteri(GLEnum pname, Int32 val)
		{
			glPatchParameteri((uint)pname, val);
		}

		public static unsafe void PatchParameterfv(GLEnum pname, float[] values)
		{
			fixed (float* ptr542 = &values[0]) { glPatchParameterfv((uint)pname, new IntPtr(ptr542)); } 
		}

		public static unsafe void BindTransformFeedback(GLEnum target, UInt32 id)
		{
			glBindTransformFeedback((uint)target, id);
		}

		public static unsafe void DeleteTransformFeedback(Int32 n, UInt32[] ids)
		{
			fixed (UInt32* ptr543 = &ids[0]) { glDeleteTransformFeedbacks(n, new IntPtr(ptr543)); } 
		}

		public static unsafe void GenTransformFeedbacks(Int32 n, [OutAttribute] UInt32[] ids)
		{
			fixed (UInt32* optr544 = ids) { glGenTransformFeedbacks(n, optr544); } 
		}

		public static unsafe bool IsTransformFeedback(UInt32 id)
		{
			return (glIsTransformFeedback(id) == 1);
		}

		public static unsafe void PauseTransformFeedback()
		{
			glPauseTransformFeedback();
		}

		public static unsafe void ResumeTransformFeedback()
		{
			glResumeTransformFeedback();
		}

		public static unsafe void DrawTransformFeedback(GLEnum mode, UInt32 id)
		{
			glDrawTransformFeedback((uint)mode, id);
		}

		public static unsafe void DrawTransformFeedbackStream(GLEnum mode, UInt32 id, UInt32 stream)
		{
			glDrawTransformFeedbackStream((uint)mode, id, stream);
		}

		public static unsafe void BeginQueryIndexed(GLEnum target, UInt32 index, UInt32 id)
		{
			glBeginQueryIndexed((uint)target, index, id);
		}

		public static unsafe void EndQueryIndexed(GLEnum target, UInt32 index)
		{
			glEndQueryIndexed((uint)target, index);
		}

		public static unsafe void GetQueryIndexediv(GLEnum target, UInt32 index, GLEnum pname, [OutAttribute] Int32[] parameters)
		{
			fixed (Int32* optr545 = parameters) { glGetQueryIndexediv((uint)target, index, (uint)pname, optr545); } 
		}

		public static unsafe void BlendColorEXT(float red, float green, float blue, float alpha)
		{
			glBlendColorEXT(red, green, blue, alpha);
		}

		public static unsafe void PolygonOffsetEXT(float factor, float bias)
		{
			glPolygonOffsetEXT(factor, bias);
		}

		public static unsafe void TexImage3DEXT(TextureTarget target, Int32 level, PixelInternalFormat internalformat, Int32 width, Int32 height, Int32 depth, Int32 border, PixelFormat format, PixelType type, IntPtr pixels)
		{
			glTexImage3DEXT((uint)target, level, (uint)internalformat, width, height, depth, border, (uint)format, (uint)type, pixels);
		}

		public static unsafe void TexSubImage3DEXT(TextureTarget target, Int32 level, Int32 xoffset, Int32 yoffset, Int32 zoffset, Int32 width, Int32 height, Int32 depth, PixelFormat format, PixelType type, IntPtr pixels)
		{
			glTexSubImage3DEXT((uint)target, level, xoffset, yoffset, zoffset, width, height, depth, (uint)format, (uint)type, pixels);
		}

		public static unsafe void GetTexFilterFuncSGIS(TextureTarget target, GLEnum filter, [OutAttribute] float[] weights)
		{
			fixed (float* optr546 = weights) { glGetTexFilterFuncSGIS((uint)target, (uint)filter, optr546); } 
		}

		public static unsafe void TexFilterFuncSGIS(TextureTarget target, GLEnum filter, Int32 n, float[] weights)
		{
			fixed (float* ptr547 = &weights[0]) { glTexFilterFuncSGIS((uint)target, (uint)filter, n, new IntPtr(ptr547)); } 
		}

		public static unsafe void TexSubImage1DEXT(TextureTarget target, Int32 level, Int32 xoffset, Int32 width, PixelFormat format, PixelType type, IntPtr pixels)
		{
			glTexSubImage1DEXT((uint)target, level, xoffset, width, (uint)format, (uint)type, pixels);
		}

		public static unsafe void TexSubImage2DEXT(TextureTarget target, Int32 level, Int32 xoffset, Int32 yoffset, Int32 width, Int32 height, PixelFormat format, PixelType type, IntPtr pixels)
		{
			glTexSubImage2DEXT((uint)target, level, xoffset, yoffset, width, height, (uint)format, (uint)type, pixels);
		}

		public static unsafe void CopyTexImage1DEXT(TextureTarget target, Int32 level, PixelInternalFormat internalformat, Int32 x, Int32 y, Int32 width, Int32 border)
		{
			glCopyTexImage1DEXT((uint)target, level, (uint)internalformat, x, y, width, border);
		}

		public static unsafe void CopyTexImage2DEXT(TextureTarget target, Int32 level, PixelInternalFormat internalformat, Int32 x, Int32 y, Int32 width, Int32 height, Int32 border)
		{
			glCopyTexImage2DEXT((uint)target, level, (uint)internalformat, x, y, width, height, border);
		}

		public static unsafe void CopyTexSubImage1DEXT(TextureTarget target, Int32 level, Int32 xoffset, Int32 x, Int32 y, Int32 width)
		{
			glCopyTexSubImage1DEXT((uint)target, level, xoffset, x, y, width);
		}

		public static unsafe void CopyTexSubImage2DEXT(TextureTarget target, Int32 level, Int32 xoffset, Int32 yoffset, Int32 x, Int32 y, Int32 width, Int32 height)
		{
			glCopyTexSubImage2DEXT((uint)target, level, xoffset, yoffset, x, y, width, height);
		}

		public static unsafe void CopyTexSubImage3DEXT(TextureTarget target, Int32 level, Int32 xoffset, Int32 yoffset, Int32 zoffset, Int32 x, Int32 y, Int32 width, Int32 height)
		{
			glCopyTexSubImage3DEXT((uint)target, level, xoffset, yoffset, zoffset, x, y, width, height);
		}

		public static unsafe void GetHistogramEXT(HistogramTargetEXT target, bool reset, PixelFormat format, PixelType type, [OutAttribute] IntPtr values)
		{
			glGetHistogramEXT((uint)target, reset ? ((byte)1) : ((byte)0), (uint)format, (uint)type, values);
		}

		public static unsafe void GetHistogramParameterfvEXT(HistogramTargetEXT target, GetHistogramParameterPNameEXT pname, [OutAttribute] float[] parameters)
		{
			fixed (float* optr548 = parameters) { glGetHistogramParameterfvEXT((uint)target, (uint)pname, optr548); } 
		}

		public static unsafe void GetHistogramParameterivEXT(HistogramTargetEXT target, GetHistogramParameterPNameEXT pname, [OutAttribute] Int32[] parameters)
		{
			fixed (Int32* optr549 = parameters) { glGetHistogramParameterivEXT((uint)target, (uint)pname, optr549); } 
		}

		public static unsafe void GetMinmaxEXT(MinmaxTargetEXT target, bool reset, PixelFormat format, PixelType type, [OutAttribute] IntPtr values)
		{
			glGetMinmaxEXT((uint)target, reset ? ((byte)1) : ((byte)0), (uint)format, (uint)type, values);
		}

		public static unsafe void GetMinmaxParameterfvEXT(MinmaxTargetEXT target, GetMinmaxParameterPNameEXT pname, [OutAttribute] float[] parameters)
		{
			fixed (float* optr550 = parameters) { glGetMinmaxParameterfvEXT((uint)target, (uint)pname, optr550); } 
		}

		public static unsafe void GetMinmaxParameterivEXT(MinmaxTargetEXT target, GetMinmaxParameterPNameEXT pname, [OutAttribute] Int32[] parameters)
		{
			fixed (Int32* optr551 = parameters) { glGetMinmaxParameterivEXT((uint)target, (uint)pname, optr551); } 
		}

		public static unsafe void HistogramEXT(HistogramTargetEXT target, Int32 width, PixelInternalFormat internalformat, bool sink)
		{
			glHistogramEXT((uint)target, width, (uint)internalformat, sink ? ((byte)1) : ((byte)0));
		}

		public static unsafe void MinmaxEXT(MinmaxTargetEXT target, PixelInternalFormat internalformat, bool sink)
		{
			glMinmaxEXT((uint)target, (uint)internalformat, sink ? ((byte)1) : ((byte)0));
		}

		public static unsafe void ResetHistogramEXT(HistogramTargetEXT target)
		{
			glResetHistogramEXT((uint)target);
		}

		public static unsafe void ResetMinmaxEXT(MinmaxTargetEXT target)
		{
			glResetMinmaxEXT((uint)target);
		}

		public static unsafe void ConvolutionFilter1DEXT(ConvolutionTargetEXT target, PixelInternalFormat internalformat, Int32 width, PixelFormat format, PixelType type, IntPtr image)
		{
			glConvolutionFilter1DEXT((uint)target, (uint)internalformat, width, (uint)format, (uint)type, image);
		}

		public static unsafe void ConvolutionFilter2DEXT(ConvolutionTargetEXT target, PixelInternalFormat internalformat, Int32 width, Int32 height, PixelFormat format, PixelType type, IntPtr image)
		{
			glConvolutionFilter2DEXT((uint)target, (uint)internalformat, width, height, (uint)format, (uint)type, image);
		}

		public static unsafe void ConvolutionParameterfEXT(ConvolutionTargetEXT target, ConvolutionParameterEXT pname, float parameters)
		{
			glConvolutionParameterfEXT((uint)target, (uint)pname, parameters);
		}

		public static unsafe void ConvolutionParameterfvEXT(ConvolutionTargetEXT target, ConvolutionParameterEXT pname, float[] parameters)
		{
			fixed (float* ptr552 = &parameters[0]) { glConvolutionParameterfvEXT((uint)target, (uint)pname, new IntPtr(ptr552)); } 
		}

		public static unsafe void ConvolutionParameteriEXT(ConvolutionTargetEXT target, ConvolutionParameterEXT pname, Int32 parameters)
		{
			glConvolutionParameteriEXT((uint)target, (uint)pname, parameters);
		}

		public static unsafe void ConvolutionParameterivEXT(ConvolutionTargetEXT target, ConvolutionParameterEXT pname, Int32[] parameters)
		{
			fixed (Int32* ptr553 = &parameters[0]) { glConvolutionParameterivEXT((uint)target, (uint)pname, new IntPtr(ptr553)); } 
		}

		public static unsafe void CopyConvolutionFilter1DEXT(ConvolutionTargetEXT target, PixelInternalFormat internalformat, Int32 x, Int32 y, Int32 width)
		{
			glCopyConvolutionFilter1DEXT((uint)target, (uint)internalformat, x, y, width);
		}

		public static unsafe void CopyConvolutionFilter2DEXT(ConvolutionTargetEXT target, PixelInternalFormat internalformat, Int32 x, Int32 y, Int32 width, Int32 height)
		{
			glCopyConvolutionFilter2DEXT((uint)target, (uint)internalformat, x, y, width, height);
		}

		public static unsafe void GetConvolutionFilterEXT(ConvolutionTargetEXT target, PixelFormat format, PixelType type, [OutAttribute] IntPtr image)
		{
			glGetConvolutionFilterEXT((uint)target, (uint)format, (uint)type, image);
		}

		public static unsafe void GetConvolutionParameterfvEXT(ConvolutionTargetEXT target, ConvolutionParameterEXT pname, [OutAttribute] float[] parameters)
		{
			fixed (float* optr554 = parameters) { glGetConvolutionParameterfvEXT((uint)target, (uint)pname, optr554); } 
		}

		public static unsafe void GetConvolutionParameterivEXT(ConvolutionTargetEXT target, ConvolutionParameterEXT pname, [OutAttribute] Int32[] parameters)
		{
			fixed (Int32* optr555 = parameters) { glGetConvolutionParameterivEXT((uint)target, (uint)pname, optr555); } 
		}

		public static unsafe void GetSeparableFilterEXT(SeparableTargetEXT target, PixelFormat format, PixelType type, [OutAttribute] IntPtr row, [OutAttribute] IntPtr column, [OutAttribute] IntPtr span)
		{
			glGetSeparableFilterEXT((uint)target, (uint)format, (uint)type, row, column, span);
		}

		public static unsafe void SeparableFilter2DEXT(SeparableTargetEXT target, PixelInternalFormat internalformat, Int32 width, Int32 height, PixelFormat format, PixelType type, IntPtr row, IntPtr column)
		{
			glSeparableFilter2DEXT((uint)target, (uint)internalformat, width, height, (uint)format, (uint)type, row, column);
		}

		public static unsafe void ColorTableSGI(ColorTableTargetSGI target, PixelInternalFormat internalformat, Int32 width, PixelFormat format, PixelType type, IntPtr table)
		{
			glColorTableSGI((uint)target, (uint)internalformat, width, (uint)format, (uint)type, table);
		}

		public static unsafe void ColorTableParameterfvSGI(ColorTableTargetSGI target, ColorTableParameterPNameSGI pname, float[] parameters)
		{
			fixed (float* ptr556 = &parameters[0]) { glColorTableParameterfvSGI((uint)target, (uint)pname, new IntPtr(ptr556)); } 
		}

		public static unsafe void ColorTableParameterivSGI(ColorTableTargetSGI target, ColorTableParameterPNameSGI pname, Int32[] parameters)
		{
			fixed (Int32* ptr557 = &parameters[0]) { glColorTableParameterivSGI((uint)target, (uint)pname, new IntPtr(ptr557)); } 
		}

		public static unsafe void CopyColorTableSGI(ColorTableTargetSGI target, PixelInternalFormat internalformat, Int32 x, Int32 y, Int32 width)
		{
			glCopyColorTableSGI((uint)target, (uint)internalformat, x, y, width);
		}

		public static unsafe void GetColorTableSGI(ColorTableTargetSGI target, PixelFormat format, PixelType type, [OutAttribute] IntPtr table)
		{
			glGetColorTableSGI((uint)target, (uint)format, (uint)type, table);
		}

		public static unsafe void GetColorTableParameterfvSGI(ColorTableTargetSGI target, GetColorTableParameterPNameSGI pname, [OutAttribute] float[] parameters)
		{
			fixed (float* optr558 = parameters) { glGetColorTableParameterfvSGI((uint)target, (uint)pname, optr558); } 
		}

		public static unsafe void GetColorTableParameterivSGI(ColorTableTargetSGI target, GetColorTableParameterPNameSGI pname, [OutAttribute] Int32[] parameters)
		{
			fixed (Int32* optr559 = parameters) { glGetColorTableParameterivSGI((uint)target, (uint)pname, optr559); } 
		}

		public static unsafe void PixelTexGenSGIX(GLEnum mode)
		{
			glPixelTexGenSGIX((uint)mode);
		}

		public static unsafe void PixelTexGenParameteriSGIS(PixelTexGenParameterNameSGIS pname, Int32 param)
		{
			glPixelTexGenParameteriSGIS((uint)pname, param);
		}

		public static unsafe void PixelTexGenParameterivSGIS(PixelTexGenParameterNameSGIS pname, Int32[] parameters)
		{
			fixed (Int32* ptr560 = &parameters[0]) { glPixelTexGenParameterivSGIS((uint)pname, new IntPtr(ptr560)); } 
		}

		public static unsafe void PixelTexGenParameterfSGIS(PixelTexGenParameterNameSGIS pname, float param)
		{
			glPixelTexGenParameterfSGIS((uint)pname, param);
		}

		public static unsafe void PixelTexGenParameterfvSGIS(PixelTexGenParameterNameSGIS pname, float[] parameters)
		{
			fixed (float* ptr561 = &parameters[0]) { glPixelTexGenParameterfvSGIS((uint)pname, new IntPtr(ptr561)); } 
		}

		public static unsafe void GetPixelTexGenParameterivSGIS(PixelTexGenParameterNameSGIS pname, [OutAttribute] Int32[] parameters)
		{
			fixed (Int32* optr562 = parameters) { glGetPixelTexGenParameterivSGIS((uint)pname, optr562); } 
		}

		public static unsafe void GetPixelTexGenParameterfvSGIS(PixelTexGenParameterNameSGIS pname, [OutAttribute] float[] parameters)
		{
			fixed (float* optr563 = parameters) { glGetPixelTexGenParameterfvSGIS((uint)pname, optr563); } 
		}

		public static unsafe void TexImage4DSGIS(TextureTarget target, Int32 level, PixelInternalFormat internalformat, Int32 width, Int32 height, Int32 depth, Int32 size4d, Int32 border, PixelFormat format, PixelType type, IntPtr pixels)
		{
			glTexImage4DSGIS((uint)target, level, (uint)internalformat, width, height, depth, size4d, border, (uint)format, (uint)type, pixels);
		}

		public static unsafe void TexSubImage4DSGIS(TextureTarget target, Int32 level, Int32 xoffset, Int32 yoffset, Int32 zoffset, Int32 woffset, Int32 width, Int32 height, Int32 depth, Int32 size4d, PixelFormat format, PixelType type, IntPtr pixels)
		{
			glTexSubImage4DSGIS((uint)target, level, xoffset, yoffset, zoffset, woffset, width, height, depth, size4d, (uint)format, (uint)type, pixels);
		}

		public static unsafe bool AreTexturesResidentEXT(Int32 n, UInt32[] textures, [OutAttribute] bool[] residences)
		{
			bool retVal;
			byte[] btr565 = new byte[1];
			fixed (byte* optr565 = btr565) { fixed (UInt32* ptr564 = &textures[0]) { retVal = (glAreTexturesResidentEXT(n, new IntPtr(ptr564), optr565) == 1); }  }
			residences = new bool[btr565.Length];
			for (int i565 = 0; i565< residences.Length; i565++)
				residences[i565] = (btr565[i565] == 1);
			 
			return retVal;
		}

		public static unsafe void BindTextureEXT(TextureTarget target, UInt32 texture)
		{
			glBindTextureEXT((uint)target, texture);
		}

		public static unsafe void DeleteTexturesEXT(Int32 n, UInt32[] textures)
		{
			fixed (UInt32* ptr566 = &textures[0]) { glDeleteTexturesEXT(n, new IntPtr(ptr566)); } 
		}

		public static unsafe void GenTexturesEXT(Int32 n, [OutAttribute] UInt32[] textures)
		{
			fixed (UInt32* optr567 = textures) { glGenTexturesEXT(n, optr567); } 
		}

		public static unsafe bool IsTextureEXT(UInt32 texture)
		{
			return (glIsTextureEXT(texture) == 1);
		}

		public static unsafe void PrioritizeTexturesEXT(Int32 n, UInt32[] textures, float[] priorities)
		{
			fixed (float* ptr569 = &priorities[0]) { fixed (UInt32* ptr568 = &textures[0]) { glPrioritizeTexturesEXT(n, new IntPtr(ptr568), new IntPtr(ptr569)); }  } 
		}

		public static unsafe void DetailTexFuncSGIS(TextureTarget target, Int32 n, float[] points)
		{
			fixed (float* ptr570 = &points[0]) { glDetailTexFuncSGIS((uint)target, n, new IntPtr(ptr570)); } 
		}

		public static unsafe void GetDetailTexFuncSGIS(TextureTarget target, [OutAttribute] float[] points)
		{
			fixed (float* optr571 = points) { glGetDetailTexFuncSGIS((uint)target, optr571); } 
		}

		public static unsafe void SharpenTexFuncSGIS(TextureTarget target, Int32 n, float[] points)
		{
			fixed (float* ptr572 = &points[0]) { glSharpenTexFuncSGIS((uint)target, n, new IntPtr(ptr572)); } 
		}

		public static unsafe void GetSharpenTexFuncSGIS(TextureTarget target, [OutAttribute] float[] points)
		{
			fixed (float* optr573 = points) { glGetSharpenTexFuncSGIS((uint)target, optr573); } 
		}

		public static unsafe void SampleMaskSGIS(float val, bool invert)
		{
			glSampleMaskSGIS(val, invert ? ((byte)1) : ((byte)0));
		}

		public static unsafe void SamplePatternSGIS(SamplePatternSGIS pattern)
		{
			glSamplePatternSGIS((uint)pattern);
		}

		public static unsafe void ArrayElementEXT(Int32 i)
		{
			glArrayElementEXT(i);
		}

		public static unsafe void ColorPointerEXT(Int32 size, ColorPointerType type, Int32 stride, Int32 count, IntPtr pointer)
		{
			glColorPointerEXT(size, (uint)type, stride, count, pointer);
		}

		public static unsafe void DrawArraysEXT(BeginMode mode, Int32 first, Int32 count)
		{
			glDrawArraysEXT((uint)mode, first, count);
		}

		public static unsafe void EdgeFlagPointerEXT(Int32 stride, Int32 count, bool[] pointer)
		{
			fixed (bool* ptr574 = &pointer[0]) { glEdgeFlagPointerEXT(stride, count, new IntPtr(ptr574)); } 
		}

		public static unsafe void GetPointervEXT(GetPointervPName pname, [OutAttribute] IntPtr[] parameters)
		{
			fixed (IntPtr* optr575 = parameters) { glGetPointervEXT((uint)pname, optr575); } 
		}

		public static unsafe void IndexPointerEXT(IndexPointerType type, Int32 stride, Int32 count, IntPtr pointer)
		{
			glIndexPointerEXT((uint)type, stride, count, pointer);
		}

		public static unsafe void NormalPointerEXT(NormalPointerType type, Int32 stride, Int32 count, IntPtr pointer)
		{
			glNormalPointerEXT((uint)type, stride, count, pointer);
		}

		public static unsafe void TexCoordPointerEXT(Int32 size, TexCoordPointerType type, Int32 stride, Int32 count, IntPtr pointer)
		{
			glTexCoordPointerEXT(size, (uint)type, stride, count, pointer);
		}

		public static unsafe void VertexPointerEXT(Int32 size, VertexPointerType type, Int32 stride, Int32 count, IntPtr pointer)
		{
			glVertexPointerEXT(size, (uint)type, stride, count, pointer);
		}

		public static unsafe void BlendEquationEXT(BlendEquationModeEXT mode)
		{
			glBlendEquationEXT((uint)mode);
		}

		public static unsafe void SpriteParameterfSGIX(GLEnum pname, float param)
		{
			glSpriteParameterfSGIX((uint)pname, param);
		}

		public static unsafe void SpriteParameterfvSGIX(GLEnum pname, float[] parameters)
		{
			fixed (float* ptr576 = &parameters[0]) { glSpriteParameterfvSGIX((uint)pname, new IntPtr(ptr576)); } 
		}

		public static unsafe void SpriteParameteriSGIX(GLEnum pname, Int32 param)
		{
			glSpriteParameteriSGIX((uint)pname, param);
		}

		public static unsafe void SpriteParameterivSGIX(GLEnum pname, Int32[] parameters)
		{
			fixed (Int32* ptr577 = &parameters[0]) { glSpriteParameterivSGIX((uint)pname, new IntPtr(ptr577)); } 
		}

		public static unsafe void PointParameterfEXT(GLEnum pname, float param)
		{
			glPointParameterfEXT((uint)pname, param);
		}

		public static unsafe void PointParameterfvEXT(GLEnum pname, float[] parameters)
		{
			fixed (float* ptr578 = &parameters[0]) { glPointParameterfvEXT((uint)pname, new IntPtr(ptr578)); } 
		}

		public static unsafe void PointParameterfSGIS(GLEnum pname, float param)
		{
			glPointParameterfSGIS((uint)pname, param);
		}

		public static unsafe void PointParameterfvSGIS(GLEnum pname, float[] parameters)
		{
			fixed (float* ptr579 = &parameters[0]) { glPointParameterfvSGIS((uint)pname, new IntPtr(ptr579)); } 
		}

		public static unsafe Int32 GetInstrumentsSGIX()
		{
			return glGetInstrumentsSGIX();
		}

		public static unsafe void InstrumentsBufferSGIX(Int32 size, [OutAttribute] Int32[] buffer)
		{
			fixed (Int32* optr580 = buffer) { glInstrumentsBufferSGIX(size, optr580); } 
		}

		public static unsafe Int32 PollInstrumentsSGIX([OutAttribute] Int32[] marker_p)
		{
			fixed (Int32* optr581 = marker_p) { return glPollInstrumentsSGIX(optr581); } 
		}

		public static unsafe void ReadInstrumentsSGIX(Int32 marker)
		{
			glReadInstrumentsSGIX(marker);
		}

		public static unsafe void StartInstrumentsSGIX()
		{
			glStartInstrumentsSGIX();
		}

		public static unsafe void StopInstrumentsSGIX(Int32 marker)
		{
			glStopInstrumentsSGIX(marker);
		}

		public static unsafe void FrameZoomSGIX(Int32 factor)
		{
			glFrameZoomSGIX(factor);
		}

		public static unsafe void TagSampleBufferSGIX()
		{
			glTagSampleBufferSGIX();
		}

		public static unsafe void DeformationMap3dSGIX(FfdTargetSGIX target, double u1, double u2, Int32 ustride, Int32 uorder, double v1, double v2, Int32 vstride, Int32 vorder, double w1, double w2, Int32 wstride, Int32 worder, double[] points)
		{
			fixed (double* ptr582 = &points[0]) { glDeformationMap3dSGIX((uint)target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, w1, w2, wstride, worder, new IntPtr(ptr582)); } 
		}

		public static unsafe void DeformationMap3fSGIX(FfdTargetSGIX target, float u1, float u2, Int32 ustride, Int32 uorder, float v1, float v2, Int32 vstride, Int32 vorder, float w1, float w2, Int32 wstride, Int32 worder, float[] points)
		{
			fixed (float* ptr583 = &points[0]) { glDeformationMap3fSGIX((uint)target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, w1, w2, wstride, worder, new IntPtr(ptr583)); } 
		}

		public static unsafe void DeformSGIX(UInt32 mask)
		{
			glDeformSGIX(mask);
		}

		public static unsafe void LoadIdentityDeformationMapSGIX(UInt32 mask)
		{
			glLoadIdentityDeformationMapSGIX(mask);
		}

		public static unsafe void ReferencePlaneSGIX(double[] equation)
		{
			fixed (double* ptr584 = &equation[0]) { glReferencePlaneSGIX(new IntPtr(ptr584)); } 
		}

		public static unsafe void FlushRasterSGIX()
		{
			glFlushRasterSGIX();
		}

		public static unsafe void FogFuncSGIS(Int32 n, float[] points)
		{
			fixed (float* ptr585 = &points[0]) { glFogFuncSGIS(n, new IntPtr(ptr585)); } 
		}

		public static unsafe void GetFogFuncSGIS([OutAttribute] float[] points)
		{
			fixed (float* optr586 = points) { glGetFogFuncSGIS(optr586); } 
		}

		public static unsafe void ImageTransformParameteriHP(GLEnum target, GLEnum pname, Int32 param)
		{
			glImageTransformParameteriHP((uint)target, (uint)pname, param);
		}

		public static unsafe void ImageTransformParameterfHP(GLEnum target, GLEnum pname, float param)
		{
			glImageTransformParameterfHP((uint)target, (uint)pname, param);
		}

		public static unsafe void ImageTransformParameterivHP(GLEnum target, GLEnum pname, Int32[] parameters)
		{
			fixed (Int32* ptr587 = &parameters[0]) { glImageTransformParameterivHP((uint)target, (uint)pname, new IntPtr(ptr587)); } 
		}

		public static unsafe void ImageTransformParameterfvHP(GLEnum target, GLEnum pname, float[] parameters)
		{
			fixed (float* ptr588 = &parameters[0]) { glImageTransformParameterfvHP((uint)target, (uint)pname, new IntPtr(ptr588)); } 
		}

		public static unsafe void GetImageTransformParameterivHP(GLEnum target, GLEnum pname, [OutAttribute] Int32[] parameters)
		{
			fixed (Int32* optr589 = parameters) { glGetImageTransformParameterivHP((uint)target, (uint)pname, optr589); } 
		}

		public static unsafe void GetImageTransformParameterfvHP(GLEnum target, GLEnum pname, [OutAttribute] float[] parameters)
		{
			fixed (float* optr590 = parameters) { glGetImageTransformParameterfvHP((uint)target, (uint)pname, optr590); } 
		}

		public static unsafe void ColorSubTableEXT(GLEnum target, Int32 start, Int32 count, PixelFormat format, PixelType type, IntPtr data)
		{
			glColorSubTableEXT((uint)target, start, count, (uint)format, (uint)type, data);
		}

		public static unsafe void CopyColorSubTableEXT(GLEnum target, Int32 start, Int32 x, Int32 y, Int32 width)
		{
			glCopyColorSubTableEXT((uint)target, start, x, y, width);
		}

		public static unsafe void HintPGI(GLEnum target, Int32 mode)
		{
			glHintPGI((uint)target, mode);
		}

		public static unsafe void ColorTableEXT(GLEnum target, PixelInternalFormat internalFormat, Int32 width, PixelFormat format, PixelType type, IntPtr table)
		{
			glColorTableEXT((uint)target, (uint)internalFormat, width, (uint)format, (uint)type, table);
		}

		public static unsafe void GetColorTableEXT(GLEnum target, PixelFormat format, PixelType type, [OutAttribute] IntPtr data)
		{
			glGetColorTableEXT((uint)target, (uint)format, (uint)type, data);
		}

		public static unsafe void GetColorTableParameterivEXT(GLEnum target, GLEnum pname, [OutAttribute] Int32[] parameters)
		{
			fixed (Int32* optr591 = parameters) { glGetColorTableParameterivEXT((uint)target, (uint)pname, optr591); } 
		}

		public static unsafe void GetColorTableParameterfvEXT(GLEnum target, GLEnum pname, [OutAttribute] float[] parameters)
		{
			fixed (float* optr592 = parameters) { glGetColorTableParameterfvEXT((uint)target, (uint)pname, optr592); } 
		}

		public static unsafe void GetListParameterfvSGIX(UInt32 list, ListParameterName pname, [OutAttribute] float[] parameters)
		{
			fixed (float* optr593 = parameters) { glGetListParameterfvSGIX(list, (uint)pname, optr593); } 
		}

		public static unsafe void GetListParameterivSGIX(UInt32 list, ListParameterName pname, [OutAttribute] Int32[] parameters)
		{
			fixed (Int32* optr594 = parameters) { glGetListParameterivSGIX(list, (uint)pname, optr594); } 
		}

		public static unsafe void ListParameterfSGIX(UInt32 list, ListParameterName pname, float param)
		{
			glListParameterfSGIX(list, (uint)pname, param);
		}

		public static unsafe void ListParameterfvSGIX(UInt32 list, ListParameterName pname, float[] parameters)
		{
			fixed (float* ptr595 = &parameters[0]) { glListParameterfvSGIX(list, (uint)pname, new IntPtr(ptr595)); } 
		}

		public static unsafe void ListParameteriSGIX(UInt32 list, ListParameterName pname, Int32 param)
		{
			glListParameteriSGIX(list, (uint)pname, param);
		}

		public static unsafe void ListParameterivSGIX(UInt32 list, ListParameterName pname, Int32[] parameters)
		{
			fixed (Int32* ptr596 = &parameters[0]) { glListParameterivSGIX(list, (uint)pname, new IntPtr(ptr596)); } 
		}

		public static unsafe void IndexMaterialEXT(MaterialFace face, GLEnum mode)
		{
			glIndexMaterialEXT((uint)face, (uint)mode);
		}

		public static unsafe void IndexFuncEXT(GLEnum func, float reference)
		{
			glIndexFuncEXT((uint)func, reference);
		}

		public static unsafe void LockArraysEXT(Int32 first, Int32 count)
		{
			glLockArraysEXT(first, count);
		}

		public static unsafe void UnlockArraysEXT()
		{
			glUnlockArraysEXT();
		}

		public static unsafe void CullParameterdvEXT(GLEnum pname, [OutAttribute] double[] parameters)
		{
			fixed (double* optr597 = parameters) { glCullParameterdvEXT((uint)pname, optr597); } 
		}

		public static unsafe void CullParameterfvEXT(GLEnum pname, [OutAttribute] float[] parameters)
		{
			fixed (float* optr598 = parameters) { glCullParameterfvEXT((uint)pname, optr598); } 
		}

		public static unsafe void FragmentColorMaterialSGIX(MaterialFace face, MaterialParameter mode)
		{
			glFragmentColorMaterialSGIX((uint)face, (uint)mode);
		}

		public static unsafe void FragmentLightfSGIX(GLEnum light, GLEnum pname, float param)
		{
			glFragmentLightfSGIX((uint)light, (uint)pname, param);
		}

		public static unsafe void FragmentLightfvSGIX(GLEnum light, GLEnum pname, float[] parameters)
		{
			fixed (float* ptr599 = &parameters[0]) { glFragmentLightfvSGIX((uint)light, (uint)pname, new IntPtr(ptr599)); } 
		}

		public static unsafe void FragmentLightiSGIX(GLEnum light, GLEnum pname, Int32 param)
		{
			glFragmentLightiSGIX((uint)light, (uint)pname, param);
		}

		public static unsafe void FragmentLightivSGIX(GLEnum light, GLEnum pname, Int32[] parameters)
		{
			fixed (Int32* ptr600 = &parameters[0]) { glFragmentLightivSGIX((uint)light, (uint)pname, new IntPtr(ptr600)); } 
		}

		public static unsafe void FragmentLightModelfSGIX(FragmentLightModelParameterSGIX pname, float param)
		{
			glFragmentLightModelfSGIX((uint)pname, param);
		}

		public static unsafe void FragmentLightModelfvSGIX(FragmentLightModelParameterSGIX pname, float[] parameters)
		{
			fixed (float* ptr601 = &parameters[0]) { glFragmentLightModelfvSGIX((uint)pname, new IntPtr(ptr601)); } 
		}

		public static unsafe void FragmentLightModeliSGIX(FragmentLightModelParameterSGIX pname, Int32 param)
		{
			glFragmentLightModeliSGIX((uint)pname, param);
		}

		public static unsafe void FragmentLightModelivSGIX(FragmentLightModelParameterSGIX pname, Int32[] parameters)
		{
			fixed (Int32* ptr602 = &parameters[0]) { glFragmentLightModelivSGIX((uint)pname, new IntPtr(ptr602)); } 
		}

		public static unsafe void FragmentMaterialfSGIX(MaterialFace face, MaterialParameter pname, float param)
		{
			glFragmentMaterialfSGIX((uint)face, (uint)pname, param);
		}

		public static unsafe void FragmentMaterialfvSGIX(MaterialFace face, MaterialParameter pname, float[] parameters)
		{
			fixed (float* ptr603 = &parameters[0]) { glFragmentMaterialfvSGIX((uint)face, (uint)pname, new IntPtr(ptr603)); } 
		}

		public static unsafe void FragmentMaterialiSGIX(MaterialFace face, MaterialParameter pname, Int32 param)
		{
			glFragmentMaterialiSGIX((uint)face, (uint)pname, param);
		}

		public static unsafe void FragmentMaterialivSGIX(MaterialFace face, MaterialParameter pname, Int32[] parameters)
		{
			fixed (Int32* ptr604 = &parameters[0]) { glFragmentMaterialivSGIX((uint)face, (uint)pname, new IntPtr(ptr604)); } 
		}

		public static unsafe void GetFragmentLightfvSGIX(GLEnum light, GLEnum pname, [OutAttribute] float[] parameters)
		{
			fixed (float* optr605 = parameters) { glGetFragmentLightfvSGIX((uint)light, (uint)pname, optr605); } 
		}

		public static unsafe void GetFragmentLightivSGIX(GLEnum light, GLEnum pname, [OutAttribute] Int32[] parameters)
		{
			fixed (Int32* optr606 = parameters) { glGetFragmentLightivSGIX((uint)light, (uint)pname, optr606); } 
		}

		public static unsafe void GetFragmentMaterialfvSGIX(MaterialFace face, MaterialParameter pname, [OutAttribute] float[] parameters)
		{
			fixed (float* optr607 = parameters) { glGetFragmentMaterialfvSGIX((uint)face, (uint)pname, optr607); } 
		}

		public static unsafe void GetFragmentMaterialivSGIX(MaterialFace face, MaterialParameter pname, [OutAttribute] Int32[] parameters)
		{
			fixed (Int32* optr608 = parameters) { glGetFragmentMaterialivSGIX((uint)face, (uint)pname, optr608); } 
		}

		public static unsafe void LightEnviSGIX(LightEnvParameterSGIX pname, Int32 param)
		{
			glLightEnviSGIX((uint)pname, param);
		}

		public static unsafe void DrawRangeElementsEXT(BeginMode mode, UInt32 start, UInt32 end, Int32 count, GLEnum type, IntPtr indices)
		{
			glDrawRangeElementsEXT((uint)mode, start, end, count, (uint)type, indices);
		}

		public static unsafe void ApplyTextureEXT(GLEnum mode)
		{
			glApplyTextureEXT((uint)mode);
		}

		public static unsafe void TextureLightEXT(GLEnum pname)
		{
			glTextureLightEXT((uint)pname);
		}

		public static unsafe void TextureMaterialEXT(MaterialFace face, MaterialParameter mode)
		{
			glTextureMaterialEXT((uint)face, (uint)mode);
		}

		public static unsafe void AsyncMarkerSGIX(UInt32 marker)
		{
			glAsyncMarkerSGIX(marker);
		}

		public static unsafe Int32 FinishAsyncSGIX([OutAttribute] UInt32[] markerp)
		{
			fixed (UInt32* optr609 = markerp) { return glFinishAsyncSGIX(optr609); } 
		}

		public static unsafe Int32 PollAsyncSGIX([OutAttribute] UInt32[] markerp)
		{
			fixed (UInt32* optr610 = markerp) { return glPollAsyncSGIX(optr610); } 
		}

		public static unsafe UInt32 GenAsyncMarkersSGIX(Int32 range)
		{
			return glGenAsyncMarkersSGIX(range);
		}

		public static unsafe void DeleteAsyncMarkersSGIX(UInt32 marker, Int32 range)
		{
			glDeleteAsyncMarkersSGIX(marker, range);
		}

		public static unsafe bool IsAsyncMarkerSGIX(UInt32 marker)
		{
			return (glIsAsyncMarkerSGIX(marker) == 1);
		}

		public static unsafe void VertexPointervINTEL(Int32 size, VertexPointerType type, IntPtr[] pointer)
		{
			fixed (IntPtr* ptr611 = &pointer[0]) { glVertexPointervINTEL(size, (uint)type, new IntPtr(ptr611)); } 
		}

		public static unsafe void NormalPointervINTEL(NormalPointerType type, IntPtr[] pointer)
		{
			fixed (IntPtr* ptr612 = &pointer[0]) { glNormalPointervINTEL((uint)type, new IntPtr(ptr612)); } 
		}

		public static unsafe void ColorPointervINTEL(Int32 size, VertexPointerType type, IntPtr[] pointer)
		{
			fixed (IntPtr* ptr613 = &pointer[0]) { glColorPointervINTEL(size, (uint)type, new IntPtr(ptr613)); } 
		}

		public static unsafe void TexCoordPointervINTEL(Int32 size, VertexPointerType type, IntPtr[] pointer)
		{
			fixed (IntPtr* ptr614 = &pointer[0]) { glTexCoordPointervINTEL(size, (uint)type, new IntPtr(ptr614)); } 
		}

		public static unsafe void PixelTransformParameteriEXT(GLEnum target, GLEnum pname, Int32 param)
		{
			glPixelTransformParameteriEXT((uint)target, (uint)pname, param);
		}

		public static unsafe void PixelTransformParameterfEXT(GLEnum target, GLEnum pname, float param)
		{
			glPixelTransformParameterfEXT((uint)target, (uint)pname, param);
		}

		public static unsafe void PixelTransformParameterivEXT(GLEnum target, GLEnum pname, Int32[] parameters)
		{
			fixed (Int32* ptr615 = &parameters[0]) { glPixelTransformParameterivEXT((uint)target, (uint)pname, new IntPtr(ptr615)); } 
		}

		public static unsafe void PixelTransformParameterfvEXT(GLEnum target, GLEnum pname, float[] parameters)
		{
			fixed (float* ptr616 = &parameters[0]) { glPixelTransformParameterfvEXT((uint)target, (uint)pname, new IntPtr(ptr616)); } 
		}

		public static unsafe void SecondaryColor3bEXT(SByte red, SByte green, SByte blue)
		{
			glSecondaryColor3bEXT(red, green, blue);
		}

		public static unsafe void SecondaryColor3bvEXT(SByte[] v)
		{
			fixed (SByte* ptr617 = &v[0]) { glSecondaryColor3bvEXT(new IntPtr(ptr617)); } 
		}

		public static unsafe void SecondaryColor3dEXT(double red, double green, double blue)
		{
			glSecondaryColor3dEXT(red, green, blue);
		}

		public static unsafe void SecondaryColor3dvEXT(double[] v)
		{
			fixed (double* ptr618 = &v[0]) { glSecondaryColor3dvEXT(new IntPtr(ptr618)); } 
		}

		public static unsafe void SecondaryColor3fEXT(float red, float green, float blue)
		{
			glSecondaryColor3fEXT(red, green, blue);
		}

		public static unsafe void SecondaryColor3fvEXT(float[] v)
		{
			fixed (float* ptr619 = &v[0]) { glSecondaryColor3fvEXT(new IntPtr(ptr619)); } 
		}

		public static unsafe void SecondaryColor3iEXT(Int32 red, Int32 green, Int32 blue)
		{
			glSecondaryColor3iEXT(red, green, blue);
		}

		public static unsafe void SecondaryColor3ivEXT(Int32[] v)
		{
			fixed (Int32* ptr620 = &v[0]) { glSecondaryColor3ivEXT(new IntPtr(ptr620)); } 
		}

		public static unsafe void SecondaryColor3sEXT(Int16 red, Int16 green, Int16 blue)
		{
			glSecondaryColor3sEXT(red, green, blue);
		}

		public static unsafe void SecondaryColor3svEXT(Int16[] v)
		{
			fixed (Int16* ptr621 = &v[0]) { glSecondaryColor3svEXT(new IntPtr(ptr621)); } 
		}

		public static unsafe void SecondaryColor3ubEXT(byte red, byte green, byte blue)
		{
			glSecondaryColor3ubEXT(red, green, blue);
		}

		public static unsafe void SecondaryColor3ubvEXT(byte[] v)
		{
			fixed (byte* ptr622 = &v[0]) { glSecondaryColor3ubvEXT(new IntPtr(ptr622)); } 
		}

		public static unsafe void SecondaryColor3uiEXT(UInt32 red, UInt32 green, UInt32 blue)
		{
			glSecondaryColor3uiEXT(red, green, blue);
		}

		public static unsafe void SecondaryColor3uivEXT(UInt32[] v)
		{
			fixed (UInt32* ptr623 = &v[0]) { glSecondaryColor3uivEXT(new IntPtr(ptr623)); } 
		}

		public static unsafe void SecondaryColor3usEXT(UInt16 red, UInt16 green, UInt16 blue)
		{
			glSecondaryColor3usEXT(red, green, blue);
		}

		public static unsafe void SecondaryColor3usvEXT(UInt16[] v)
		{
			fixed (UInt16* ptr624 = &v[0]) { glSecondaryColor3usvEXT(new IntPtr(ptr624)); } 
		}

		public static unsafe void SecondaryColorPointerEXT(Int32 size, ColorPointerType type, Int32 stride, IntPtr pointer)
		{
			glSecondaryColorPointerEXT(size, (uint)type, stride, pointer);
		}

		public static unsafe void TextureNormalEXT(GLEnum mode)
		{
			glTextureNormalEXT((uint)mode);
		}

		public static unsafe void MultiDrawArraysEXT(BeginMode mode, [OutAttribute] Int32[] first, [OutAttribute] Int32[] count, Int32 primcount)
		{
			fixed (Int32* optr626 = count) { fixed (Int32* optr625 = first) { glMultiDrawArraysEXT((uint)mode, optr625, optr626, primcount); }  } 
		}

		public static unsafe void MultiDrawElementsEXT(BeginMode mode, Int32[] count, GLEnum type, IntPtr[] indices, Int32 primcount)
		{
			fixed (IntPtr* ptr628 = &indices[0]) { fixed (Int32* ptr627 = &count[0]) { glMultiDrawElementsEXT((uint)mode, new IntPtr(ptr627), (uint)type, new IntPtr(ptr628), primcount); }  } 
		}

		public static unsafe void FogCoordfEXT(float coord)
		{
			glFogCoordfEXT(coord);
		}

		public static unsafe void FogCoordfvEXT(float[] coord)
		{
			fixed (float* ptr629 = &coord[0]) { glFogCoordfvEXT(new IntPtr(ptr629)); } 
		}

		public static unsafe void FogCoorddEXT(double coord)
		{
			glFogCoorddEXT(coord);
		}

		public static unsafe void FogCoorddvEXT(double[] coord)
		{
			fixed (double* ptr630 = &coord[0]) { glFogCoorddvEXT(new IntPtr(ptr630)); } 
		}

		public static unsafe void FogCoordPointerEXT(GLEnum type, Int32 stride, IntPtr pointer)
		{
			glFogCoordPointerEXT((uint)type, stride, pointer);
		}

		public static unsafe void Tangent3bEXT(SByte tx, SByte ty, SByte tz)
		{
			glTangent3bEXT(tx, ty, tz);
		}

		public static unsafe void Tangent3bvEXT(SByte[] v)
		{
			fixed (SByte* ptr631 = &v[0]) { glTangent3bvEXT(new IntPtr(ptr631)); } 
		}

		public static unsafe void Tangent3dEXT(double tx, double ty, double tz)
		{
			glTangent3dEXT(tx, ty, tz);
		}

		public static unsafe void Tangent3dvEXT(double[] v)
		{
			fixed (double* ptr632 = &v[0]) { glTangent3dvEXT(new IntPtr(ptr632)); } 
		}

		public static unsafe void Tangent3fEXT(float tx, float ty, float tz)
		{
			glTangent3fEXT(tx, ty, tz);
		}

		public static unsafe void Tangent3fvEXT(float[] v)
		{
			fixed (float* ptr633 = &v[0]) { glTangent3fvEXT(new IntPtr(ptr633)); } 
		}

		public static unsafe void Tangent3iEXT(Int32 tx, Int32 ty, Int32 tz)
		{
			glTangent3iEXT(tx, ty, tz);
		}

		public static unsafe void Tangent3ivEXT(Int32[] v)
		{
			fixed (Int32* ptr634 = &v[0]) { glTangent3ivEXT(new IntPtr(ptr634)); } 
		}

		public static unsafe void Tangent3sEXT(Int16 tx, Int16 ty, Int16 tz)
		{
			glTangent3sEXT(tx, ty, tz);
		}

		public static unsafe void Tangent3svEXT(Int16[] v)
		{
			fixed (Int16* ptr635 = &v[0]) { glTangent3svEXT(new IntPtr(ptr635)); } 
		}

		public static unsafe void Binormal3bEXT(SByte bx, SByte by, SByte bz)
		{
			glBinormal3bEXT(bx, by, bz);
		}

		public static unsafe void Binormal3bvEXT(SByte[] v)
		{
			fixed (SByte* ptr636 = &v[0]) { glBinormal3bvEXT(new IntPtr(ptr636)); } 
		}

		public static unsafe void Binormal3dEXT(double bx, double by, double bz)
		{
			glBinormal3dEXT(bx, by, bz);
		}

		public static unsafe void Binormal3dvEXT(double[] v)
		{
			fixed (double* ptr637 = &v[0]) { glBinormal3dvEXT(new IntPtr(ptr637)); } 
		}

		public static unsafe void Binormal3fEXT(float bx, float by, float bz)
		{
			glBinormal3fEXT(bx, by, bz);
		}

		public static unsafe void Binormal3fvEXT(float[] v)
		{
			fixed (float* ptr638 = &v[0]) { glBinormal3fvEXT(new IntPtr(ptr638)); } 
		}

		public static unsafe void Binormal3iEXT(Int32 bx, Int32 by, Int32 bz)
		{
			glBinormal3iEXT(bx, by, bz);
		}

		public static unsafe void Binormal3ivEXT(Int32[] v)
		{
			fixed (Int32* ptr639 = &v[0]) { glBinormal3ivEXT(new IntPtr(ptr639)); } 
		}

		public static unsafe void Binormal3sEXT(Int16 bx, Int16 by, Int16 bz)
		{
			glBinormal3sEXT(bx, by, bz);
		}

		public static unsafe void Binormal3svEXT(Int16[] v)
		{
			fixed (Int16* ptr640 = &v[0]) { glBinormal3svEXT(new IntPtr(ptr640)); } 
		}

		public static unsafe void TangentPointerEXT(GLEnum type, Int32 stride, IntPtr pointer)
		{
			glTangentPointerEXT((uint)type, stride, pointer);
		}

		public static unsafe void BinormalPointerEXT(GLEnum type, Int32 stride, IntPtr pointer)
		{
			glBinormalPointerEXT((uint)type, stride, pointer);
		}

		public static unsafe void FinishTextureSUNX()
		{
			glFinishTextureSUNX();
		}

		public static unsafe void GlobalAlphaFactorbSUN(SByte factor)
		{
			glGlobalAlphaFactorbSUN(factor);
		}

		public static unsafe void GlobalAlphaFactorsSUN(Int16 factor)
		{
			glGlobalAlphaFactorsSUN(factor);
		}

		public static unsafe void GlobalAlphaFactoriSUN(Int32 factor)
		{
			glGlobalAlphaFactoriSUN(factor);
		}

		public static unsafe void GlobalAlphaFactorfSUN(float factor)
		{
			glGlobalAlphaFactorfSUN(factor);
		}

		public static unsafe void GlobalAlphaFactordSUN(double factor)
		{
			glGlobalAlphaFactordSUN(factor);
		}

		public static unsafe void GlobalAlphaFactorubSUN(byte factor)
		{
			glGlobalAlphaFactorubSUN(factor);
		}

		public static unsafe void GlobalAlphaFactorusSUN(UInt16 factor)
		{
			glGlobalAlphaFactorusSUN(factor);
		}

		public static unsafe void GlobalAlphaFactoruiSUN(UInt32 factor)
		{
			glGlobalAlphaFactoruiSUN(factor);
		}

		public static unsafe void ReplacementCodeuiSUN(UInt32 code)
		{
			glReplacementCodeuiSUN(code);
		}

		public static unsafe void ReplacementCodeusSUN(UInt16 code)
		{
			glReplacementCodeusSUN(code);
		}

		public static unsafe void ReplacementCodeubSUN(byte code)
		{
			glReplacementCodeubSUN(code);
		}

		public static unsafe void ReplacementCodeuivSUN(UInt32[] code)
		{
			fixed (UInt32* ptr641 = &code[0]) { glReplacementCodeuivSUN(new IntPtr(ptr641)); } 
		}

		public static unsafe void ReplacementCodeusvSUN(UInt16[] code)
		{
			fixed (UInt16* ptr642 = &code[0]) { glReplacementCodeusvSUN(new IntPtr(ptr642)); } 
		}

		public static unsafe void ReplacementCodeubvSUN(byte[] code)
		{
			fixed (byte* ptr643 = &code[0]) { glReplacementCodeubvSUN(new IntPtr(ptr643)); } 
		}

		public static unsafe void ReplacementCodePointerSUN(GLEnum type, Int32 stride, IntPtr[] pointer)
		{
			fixed (IntPtr* ptr644 = &pointer[0]) { glReplacementCodePointerSUN((uint)type, stride, new IntPtr(ptr644)); } 
		}

		public static unsafe void Color4ubVertex2fSUN(byte r, byte g, byte b, byte a, float x, float y)
		{
			glColor4ubVertex2fSUN(r, g, b, a, x, y);
		}

		public static unsafe void Color4ubVertex2fvSUN(byte[] c, float[] v)
		{
			fixed (float* ptr646 = &v[0]) { fixed (byte* ptr645 = &c[0]) { glColor4ubVertex2fvSUN(new IntPtr(ptr645), new IntPtr(ptr646)); }  } 
		}

		public static unsafe void Color4ubVertex3fSUN(byte r, byte g, byte b, byte a, float x, float y, float z)
		{
			glColor4ubVertex3fSUN(r, g, b, a, x, y, z);
		}

		public static unsafe void Color4ubVertex3fvSUN(byte[] c, float[] v)
		{
			fixed (float* ptr648 = &v[0]) { fixed (byte* ptr647 = &c[0]) { glColor4ubVertex3fvSUN(new IntPtr(ptr647), new IntPtr(ptr648)); }  } 
		}

		public static unsafe void Color3fVertex3fSUN(float r, float g, float b, float x, float y, float z)
		{
			glColor3fVertex3fSUN(r, g, b, x, y, z);
		}

		public static unsafe void Color3fVertex3fvSUN(float[] c, float[] v)
		{
			fixed (float* ptr650 = &v[0]) { fixed (float* ptr649 = &c[0]) { glColor3fVertex3fvSUN(new IntPtr(ptr649), new IntPtr(ptr650)); }  } 
		}

		public static unsafe void Normal3fVertex3fSUN(float nx, float ny, float nz, float x, float y, float z)
		{
			glNormal3fVertex3fSUN(nx, ny, nz, x, y, z);
		}

		public static unsafe void Normal3fVertex3fvSUN(float[] n, float[] v)
		{
			fixed (float* ptr652 = &v[0]) { fixed (float* ptr651 = &n[0]) { glNormal3fVertex3fvSUN(new IntPtr(ptr651), new IntPtr(ptr652)); }  } 
		}

		public static unsafe void Color4fNormal3fVertex3fSUN(float r, float g, float b, float a, float nx, float ny, float nz, float x, float y, float z)
		{
			glColor4fNormal3fVertex3fSUN(r, g, b, a, nx, ny, nz, x, y, z);
		}

		public static unsafe void Color4fNormal3fVertex3fvSUN(float[] c, float[] n, float[] v)
		{
			fixed (float* ptr655 = &v[0]) { fixed (float* ptr654 = &n[0]) { fixed (float* ptr653 = &c[0]) { glColor4fNormal3fVertex3fvSUN(new IntPtr(ptr653), new IntPtr(ptr654), new IntPtr(ptr655)); }  }  } 
		}

		public static unsafe void TexCoord2fVertex3fSUN(float s, float t, float x, float y, float z)
		{
			glTexCoord2fVertex3fSUN(s, t, x, y, z);
		}

		public static unsafe void TexCoord2fVertex3fvSUN(float[] tc, float[] v)
		{
			fixed (float* ptr657 = &v[0]) { fixed (float* ptr656 = &tc[0]) { glTexCoord2fVertex3fvSUN(new IntPtr(ptr656), new IntPtr(ptr657)); }  } 
		}

		public static unsafe void TexCoord4fVertex4fSUN(float s, float t, float p, float q, float x, float y, float z, float w)
		{
			glTexCoord4fVertex4fSUN(s, t, p, q, x, y, z, w);
		}

		public static unsafe void TexCoord4fVertex4fvSUN(float[] tc, float[] v)
		{
			fixed (float* ptr659 = &v[0]) { fixed (float* ptr658 = &tc[0]) { glTexCoord4fVertex4fvSUN(new IntPtr(ptr658), new IntPtr(ptr659)); }  } 
		}

		public static unsafe void TexCoord2fColor4ubVertex3fSUN(float s, float t, byte r, byte g, byte b, byte a, float x, float y, float z)
		{
			glTexCoord2fColor4ubVertex3fSUN(s, t, r, g, b, a, x, y, z);
		}

		public static unsafe void TexCoord2fColor4ubVertex3fvSUN(float[] tc, byte[] c, float[] v)
		{
			fixed (float* ptr662 = &v[0]) { fixed (byte* ptr661 = &c[0]) { fixed (float* ptr660 = &tc[0]) { glTexCoord2fColor4ubVertex3fvSUN(new IntPtr(ptr660), new IntPtr(ptr661), new IntPtr(ptr662)); }  }  } 
		}

		public static unsafe void TexCoord2fColor3fVertex3fSUN(float s, float t, float r, float g, float b, float x, float y, float z)
		{
			glTexCoord2fColor3fVertex3fSUN(s, t, r, g, b, x, y, z);
		}

		public static unsafe void TexCoord2fColor3fVertex3fvSUN(float[] tc, float[] c, float[] v)
		{
			fixed (float* ptr665 = &v[0]) { fixed (float* ptr664 = &c[0]) { fixed (float* ptr663 = &tc[0]) { glTexCoord2fColor3fVertex3fvSUN(new IntPtr(ptr663), new IntPtr(ptr664), new IntPtr(ptr665)); }  }  } 
		}

		public static unsafe void TexCoord2fNormal3fVertex3fSUN(float s, float t, float nx, float ny, float nz, float x, float y, float z)
		{
			glTexCoord2fNormal3fVertex3fSUN(s, t, nx, ny, nz, x, y, z);
		}

		public static unsafe void TexCoord2fNormal3fVertex3fvSUN(float[] tc, float[] n, float[] v)
		{
			fixed (float* ptr668 = &v[0]) { fixed (float* ptr667 = &n[0]) { fixed (float* ptr666 = &tc[0]) { glTexCoord2fNormal3fVertex3fvSUN(new IntPtr(ptr666), new IntPtr(ptr667), new IntPtr(ptr668)); }  }  } 
		}

		public static unsafe void TexCoord2fColor4fNormal3fVertex3fSUN(float s, float t, float r, float g, float b, float a, float nx, float ny, float nz, float x, float y, float z)
		{
			glTexCoord2fColor4fNormal3fVertex3fSUN(s, t, r, g, b, a, nx, ny, nz, x, y, z);
		}

		public static unsafe void TexCoord2fColor4fNormal3fVertex3fvSUN(float[] tc, float[] c, float[] n, float[] v)
		{
			fixed (float* ptr672 = &v[0]) { fixed (float* ptr671 = &n[0]) { fixed (float* ptr670 = &c[0]) { fixed (float* ptr669 = &tc[0]) { glTexCoord2fColor4fNormal3fVertex3fvSUN(new IntPtr(ptr669), new IntPtr(ptr670), new IntPtr(ptr671), new IntPtr(ptr672)); }  }  }  } 
		}

		public static unsafe void TexCoord4fColor4fNormal3fVertex4fSUN(float s, float t, float p, float q, float r, float g, float b, float a, float nx, float ny, float nz, float x, float y, float z, float w)
		{
			glTexCoord4fColor4fNormal3fVertex4fSUN(s, t, p, q, r, g, b, a, nx, ny, nz, x, y, z, w);
		}

		public static unsafe void TexCoord4fColor4fNormal3fVertex4fvSUN(float[] tc, float[] c, float[] n, float[] v)
		{
			fixed (float* ptr676 = &v[0]) { fixed (float* ptr675 = &n[0]) { fixed (float* ptr674 = &c[0]) { fixed (float* ptr673 = &tc[0]) { glTexCoord4fColor4fNormal3fVertex4fvSUN(new IntPtr(ptr673), new IntPtr(ptr674), new IntPtr(ptr675), new IntPtr(ptr676)); }  }  }  } 
		}

		public static unsafe void ReplacementCodeuiVertex3fSUN(UInt32 rc, float x, float y, float z)
		{
			glReplacementCodeuiVertex3fSUN(rc, x, y, z);
		}

		public static unsafe void ReplacementCodeuiVertex3fvSUN(UInt32[] rc, float[] v)
		{
			fixed (float* ptr678 = &v[0]) { fixed (UInt32* ptr677 = &rc[0]) { glReplacementCodeuiVertex3fvSUN(new IntPtr(ptr677), new IntPtr(ptr678)); }  } 
		}

		public static unsafe void ReplacementCodeuiColor4ubVertex3fSUN(UInt32 rc, byte r, byte g, byte b, byte a, float x, float y, float z)
		{
			glReplacementCodeuiColor4ubVertex3fSUN(rc, r, g, b, a, x, y, z);
		}

		public static unsafe void ReplacementCodeuiColor4ubVertex3fvSUN(UInt32[] rc, byte[] c, float[] v)
		{
			fixed (float* ptr681 = &v[0]) { fixed (byte* ptr680 = &c[0]) { fixed (UInt32* ptr679 = &rc[0]) { glReplacementCodeuiColor4ubVertex3fvSUN(new IntPtr(ptr679), new IntPtr(ptr680), new IntPtr(ptr681)); }  }  } 
		}

		public static unsafe void ReplacementCodeuiColor3fVertex3fSUN(UInt32 rc, float r, float g, float b, float x, float y, float z)
		{
			glReplacementCodeuiColor3fVertex3fSUN(rc, r, g, b, x, y, z);
		}

		public static unsafe void ReplacementCodeuiColor3fVertex3fvSUN(UInt32[] rc, float[] c, float[] v)
		{
			fixed (float* ptr684 = &v[0]) { fixed (float* ptr683 = &c[0]) { fixed (UInt32* ptr682 = &rc[0]) { glReplacementCodeuiColor3fVertex3fvSUN(new IntPtr(ptr682), new IntPtr(ptr683), new IntPtr(ptr684)); }  }  } 
		}

		public static unsafe void ReplacementCodeuiNormal3fVertex3fSUN(UInt32 rc, float nx, float ny, float nz, float x, float y, float z)
		{
			glReplacementCodeuiNormal3fVertex3fSUN(rc, nx, ny, nz, x, y, z);
		}

		public static unsafe void ReplacementCodeuiNormal3fVertex3fvSUN(UInt32[] rc, float[] n, float[] v)
		{
			fixed (float* ptr687 = &v[0]) { fixed (float* ptr686 = &n[0]) { fixed (UInt32* ptr685 = &rc[0]) { glReplacementCodeuiNormal3fVertex3fvSUN(new IntPtr(ptr685), new IntPtr(ptr686), new IntPtr(ptr687)); }  }  } 
		}

		public static unsafe void ReplacementCodeuiColor4fNormal3fVertex3fSUN(UInt32 rc, float r, float g, float b, float a, float nx, float ny, float nz, float x, float y, float z)
		{
			glReplacementCodeuiColor4fNormal3fVertex3fSUN(rc, r, g, b, a, nx, ny, nz, x, y, z);
		}

		public static unsafe void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(UInt32[] rc, float[] c, float[] n, float[] v)
		{
			fixed (float* ptr691 = &v[0]) { fixed (float* ptr690 = &n[0]) { fixed (float* ptr689 = &c[0]) { fixed (UInt32* ptr688 = &rc[0]) { glReplacementCodeuiColor4fNormal3fVertex3fvSUN(new IntPtr(ptr688), new IntPtr(ptr689), new IntPtr(ptr690), new IntPtr(ptr691)); }  }  }  } 
		}

		public static unsafe void ReplacementCodeuiTexCoord2fVertex3fSUN(UInt32 rc, float s, float t, float x, float y, float z)
		{
			glReplacementCodeuiTexCoord2fVertex3fSUN(rc, s, t, x, y, z);
		}

		public static unsafe void ReplacementCodeuiTexCoord2fVertex3fvSUN(UInt32[] rc, float[] tc, float[] v)
		{
			fixed (float* ptr694 = &v[0]) { fixed (float* ptr693 = &tc[0]) { fixed (UInt32* ptr692 = &rc[0]) { glReplacementCodeuiTexCoord2fVertex3fvSUN(new IntPtr(ptr692), new IntPtr(ptr693), new IntPtr(ptr694)); }  }  } 
		}

		public static unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fSUN(UInt32 rc, float s, float t, float nx, float ny, float nz, float x, float y, float z)
		{
			glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN(rc, s, t, nx, ny, nz, x, y, z);
		}

		public static unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(UInt32[] rc, float[] tc, float[] n, float[] v)
		{
			fixed (float* ptr698 = &v[0]) { fixed (float* ptr697 = &n[0]) { fixed (float* ptr696 = &tc[0]) { fixed (UInt32* ptr695 = &rc[0]) { glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(new IntPtr(ptr695), new IntPtr(ptr696), new IntPtr(ptr697), new IntPtr(ptr698)); }  }  }  } 
		}

		public static unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN(UInt32 rc, float s, float t, float r, float g, float b, float a, float nx, float ny, float nz, float x, float y, float z)
		{
			glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN(rc, s, t, r, g, b, a, nx, ny, nz, x, y, z);
		}

		public static unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(UInt32[] rc, float[] tc, float[] c, float[] n, float[] v)
		{
			fixed (float* ptr703 = &v[0]) { fixed (float* ptr702 = &n[0]) { fixed (float* ptr701 = &c[0]) { fixed (float* ptr700 = &tc[0]) { fixed (UInt32* ptr699 = &rc[0]) { glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(new IntPtr(ptr699), new IntPtr(ptr700), new IntPtr(ptr701), new IntPtr(ptr702), new IntPtr(ptr703)); }  }  }  }  } 
		}

		public static unsafe void BlendFuncSeparateEXT(GLEnum sfactorRGB, GLEnum dfactorRGB, GLEnum sfactorAlpha, GLEnum dfactorAlpha)
		{
			glBlendFuncSeparateEXT((uint)sfactorRGB, (uint)dfactorRGB, (uint)sfactorAlpha, (uint)dfactorAlpha);
		}

		public static unsafe void BlendFuncSeparateINGR(GLEnum sfactorRGB, GLEnum dfactorRGB, GLEnum sfactorAlpha, GLEnum dfactorAlpha)
		{
			glBlendFuncSeparateINGR((uint)sfactorRGB, (uint)dfactorRGB, (uint)sfactorAlpha, (uint)dfactorAlpha);
		}

		public static unsafe void VertexWeightfEXT(float weight)
		{
			glVertexWeightfEXT(weight);
		}

		public static unsafe void VertexWeightfvEXT(float[] weight)
		{
			fixed (float* ptr704 = &weight[0]) { glVertexWeightfvEXT(new IntPtr(ptr704)); } 
		}

		public static unsafe void VertexWeightPointerEXT(Int32 size, GLEnum type, Int32 stride, IntPtr pointer)
		{
			glVertexWeightPointerEXT(size, (uint)type, stride, pointer);
		}

		public static unsafe void FlushVertexArrayRangeNV()
		{
			glFlushVertexArrayRangeNV();
		}

		public static unsafe void VertexArrayRangeNV(Int32 length, IntPtr pointer)
		{
			glVertexArrayRangeNV(length, pointer);
		}

		public static unsafe void CombinerParameterfvNV(GLEnum pname, float[] parameters)
		{
			fixed (float* ptr705 = &parameters[0]) { glCombinerParameterfvNV((uint)pname, new IntPtr(ptr705)); } 
		}

		public static unsafe void CombinerParameterfNV(GLEnum pname, float param)
		{
			glCombinerParameterfNV((uint)pname, param);
		}

		public static unsafe void CombinerParameterivNV(GLEnum pname, Int32[] parameters)
		{
			fixed (Int32* ptr706 = &parameters[0]) { glCombinerParameterivNV((uint)pname, new IntPtr(ptr706)); } 
		}

		public static unsafe void CombinerParameteriNV(GLEnum pname, Int32 param)
		{
			glCombinerParameteriNV((uint)pname, param);
		}

		public static unsafe void CombinerInputNV(GLEnum stage, GLEnum portion, GLEnum variable, GLEnum input, GLEnum mapping, GLEnum componentUsage)
		{
			glCombinerInputNV((uint)stage, (uint)portion, (uint)variable, (uint)input, (uint)mapping, (uint)componentUsage);
		}

		public static unsafe void CombinerOutputNV(GLEnum stage, GLEnum portion, GLEnum abOutput, GLEnum cdOutput, GLEnum sumOutput, GLEnum scale, GLEnum bias, bool abDotProduct, bool cdDotProduct, bool muxSum)
		{
			glCombinerOutputNV((uint)stage, (uint)portion, (uint)abOutput, (uint)cdOutput, (uint)sumOutput, (uint)scale, (uint)bias, abDotProduct ? ((byte)1) : ((byte)0), cdDotProduct ? ((byte)1) : ((byte)0), muxSum ? ((byte)1) : ((byte)0));
		}

		public static unsafe void FinalCombinerInputNV(GLEnum variable, GLEnum input, GLEnum mapping, GLEnum componentUsage)
		{
			glFinalCombinerInputNV((uint)variable, (uint)input, (uint)mapping, (uint)componentUsage);
		}

		public static unsafe void GetCombinerInputParameterfvNV(GLEnum stage, GLEnum portion, GLEnum variable, GLEnum pname, [OutAttribute] float[] parameters)
		{
			fixed (float* optr707 = parameters) { glGetCombinerInputParameterfvNV((uint)stage, (uint)portion, (uint)variable, (uint)pname, optr707); } 
		}

		public static unsafe void GetCombinerInputParameterivNV(GLEnum stage, GLEnum portion, GLEnum variable, GLEnum pname, [OutAttribute] Int32[] parameters)
		{
			fixed (Int32* optr708 = parameters) { glGetCombinerInputParameterivNV((uint)stage, (uint)portion, (uint)variable, (uint)pname, optr708); } 
		}

		public static unsafe void GetCombinerOutputParameterfvNV(GLEnum stage, GLEnum portion, GLEnum pname, [OutAttribute] float[] parameters)
		{
			fixed (float* optr709 = parameters) { glGetCombinerOutputParameterfvNV((uint)stage, (uint)portion, (uint)pname, optr709); } 
		}

		public static unsafe void GetCombinerOutputParameterivNV(GLEnum stage, GLEnum portion, GLEnum pname, [OutAttribute] Int32[] parameters)
		{
			fixed (Int32* optr710 = parameters) { glGetCombinerOutputParameterivNV((uint)stage, (uint)portion, (uint)pname, optr710); } 
		}

		public static unsafe void GetFinalCombinerInputParameterfvNV(GLEnum variable, GLEnum pname, [OutAttribute] float[] parameters)
		{
			fixed (float* optr711 = parameters) { glGetFinalCombinerInputParameterfvNV((uint)variable, (uint)pname, optr711); } 
		}

		public static unsafe void GetFinalCombinerInputParameterivNV(GLEnum variable, GLEnum pname, [OutAttribute] Int32[] parameters)
		{
			fixed (Int32* optr712 = parameters) { glGetFinalCombinerInputParameterivNV((uint)variable, (uint)pname, optr712); } 
		}

		public static unsafe void ResizeBuffersMESA()
		{
			glResizeBuffersMESA();
		}

		public static unsafe void WindowPos2dMESA(double x, double y)
		{
			glWindowPos2dMESA(x, y);
		}

		public static unsafe void WindowPos2dvMESA(double[] v)
		{
			fixed (double* ptr713 = &v[0]) { glWindowPos2dvMESA(new IntPtr(ptr713)); } 
		}

		public static unsafe void WindowPos2fMESA(float x, float y)
		{
			glWindowPos2fMESA(x, y);
		}

		public static unsafe void WindowPos2fvMESA(float[] v)
		{
			fixed (float* ptr714 = &v[0]) { glWindowPos2fvMESA(new IntPtr(ptr714)); } 
		}

		public static unsafe void WindowPos2iMESA(Int32 x, Int32 y)
		{
			glWindowPos2iMESA(x, y);
		}

		public static unsafe void WindowPos2ivMESA(Int32[] v)
		{
			fixed (Int32* ptr715 = &v[0]) { glWindowPos2ivMESA(new IntPtr(ptr715)); } 
		}

		public static unsafe void WindowPos2sMESA(Int16 x, Int16 y)
		{
			glWindowPos2sMESA(x, y);
		}

		public static unsafe void WindowPos2svMESA(Int16[] v)
		{
			fixed (Int16* ptr716 = &v[0]) { glWindowPos2svMESA(new IntPtr(ptr716)); } 
		}

		public static unsafe void WindowPos3dMESA(double x, double y, double z)
		{
			glWindowPos3dMESA(x, y, z);
		}

		public static unsafe void WindowPos3dvMESA(double[] v)
		{
			fixed (double* ptr717 = &v[0]) { glWindowPos3dvMESA(new IntPtr(ptr717)); } 
		}

		public static unsafe void WindowPos3fMESA(float x, float y, float z)
		{
			glWindowPos3fMESA(x, y, z);
		}

		public static unsafe void WindowPos3fvMESA(float[] v)
		{
			fixed (float* ptr718 = &v[0]) { glWindowPos3fvMESA(new IntPtr(ptr718)); } 
		}

		public static unsafe void WindowPos3iMESA(Int32 x, Int32 y, Int32 z)
		{
			glWindowPos3iMESA(x, y, z);
		}

		public static unsafe void WindowPos3ivMESA(Int32[] v)
		{
			fixed (Int32* ptr719 = &v[0]) { glWindowPos3ivMESA(new IntPtr(ptr719)); } 
		}

		public static unsafe void WindowPos3sMESA(Int16 x, Int16 y, Int16 z)
		{
			glWindowPos3sMESA(x, y, z);
		}

		public static unsafe void WindowPos3svMESA(Int16[] v)
		{
			fixed (Int16* ptr720 = &v[0]) { glWindowPos3svMESA(new IntPtr(ptr720)); } 
		}

		public static unsafe void WindowPos4dMESA(double x, double y, double z, double w)
		{
			glWindowPos4dMESA(x, y, z, w);
		}

		public static unsafe void WindowPos4dvMESA(double[] v)
		{
			fixed (double* ptr721 = &v[0]) { glWindowPos4dvMESA(new IntPtr(ptr721)); } 
		}

		public static unsafe void WindowPos4fMESA(float x, float y, float z, float w)
		{
			glWindowPos4fMESA(x, y, z, w);
		}

		public static unsafe void WindowPos4fvMESA(float[] v)
		{
			fixed (float* ptr722 = &v[0]) { glWindowPos4fvMESA(new IntPtr(ptr722)); } 
		}

		public static unsafe void WindowPos4iMESA(Int32 x, Int32 y, Int32 z, Int32 w)
		{
			glWindowPos4iMESA(x, y, z, w);
		}

		public static unsafe void WindowPos4ivMESA(Int32[] v)
		{
			fixed (Int32* ptr723 = &v[0]) { glWindowPos4ivMESA(new IntPtr(ptr723)); } 
		}

		public static unsafe void WindowPos4sMESA(Int16 x, Int16 y, Int16 z, Int16 w)
		{
			glWindowPos4sMESA(x, y, z, w);
		}

		public static unsafe void WindowPos4svMESA(Int16[] v)
		{
			fixed (Int16* ptr724 = &v[0]) { glWindowPos4svMESA(new IntPtr(ptr724)); } 
		}

		public static unsafe void MultiModeDrawArraysIBM(BeginMode[] mode, Int32[] first, Int32[] count, Int32 primcount, Int32 modestride)
		{
			fixed (Int32* ptr727 = &count[0]) { fixed (Int32* ptr726 = &first[0]) { fixed (BeginMode* ptr725 = &mode[0]) { glMultiModeDrawArraysIBM(new IntPtr(ptr725), new IntPtr(ptr726), new IntPtr(ptr727), primcount, modestride); }  }  } 
		}

		public static unsafe void MultiModeDrawElementsIBM(BeginMode[] mode, Int32[] count, GLEnum type, IntPtr[] indices, Int32 primcount, Int32 modestride)
		{
			fixed (IntPtr* ptr730 = &indices[0]) { fixed (Int32* ptr729 = &count[0]) { fixed (BeginMode* ptr728 = &mode[0]) { glMultiModeDrawElementsIBM(new IntPtr(ptr728), new IntPtr(ptr729), (uint)type, new IntPtr(ptr730), primcount, modestride); }  }  } 
		}

		public static unsafe void ColorPointerListIBM(Int32 size, ColorPointerType type, Int32 stride, IntPtr[] pointer, Int32 ptrstride)
		{
			fixed (IntPtr* ptr731 = &pointer[0]) { glColorPointerListIBM(size, (uint)type, stride, new IntPtr(ptr731), ptrstride); } 
		}

		public static unsafe void SecondaryColorPointerListIBM(Int32 size, GLEnum type, Int32 stride, IntPtr[] pointer, Int32 ptrstride)
		{
			fixed (IntPtr* ptr732 = &pointer[0]) { glSecondaryColorPointerListIBM(size, (uint)type, stride, new IntPtr(ptr732), ptrstride); } 
		}

		public static unsafe void EdgeFlagPointerListIBM(Int32 stride, IntPtr[] pointer, Int32 ptrstride)
		{
			fixed (IntPtr* ptr733 = &pointer[0]) { glEdgeFlagPointerListIBM(stride, new IntPtr(ptr733), ptrstride); } 
		}

		public static unsafe void FogCoordPointerListIBM(GLEnum type, Int32 stride, IntPtr[] pointer, Int32 ptrstride)
		{
			fixed (IntPtr* ptr734 = &pointer[0]) { glFogCoordPointerListIBM((uint)type, stride, new IntPtr(ptr734), ptrstride); } 
		}

		public static unsafe void IndexPointerListIBM(IndexPointerType type, Int32 stride, IntPtr[] pointer, Int32 ptrstride)
		{
			fixed (IntPtr* ptr735 = &pointer[0]) { glIndexPointerListIBM((uint)type, stride, new IntPtr(ptr735), ptrstride); } 
		}

		public static unsafe void NormalPointerListIBM(NormalPointerType type, Int32 stride, IntPtr[] pointer, Int32 ptrstride)
		{
			fixed (IntPtr* ptr736 = &pointer[0]) { glNormalPointerListIBM((uint)type, stride, new IntPtr(ptr736), ptrstride); } 
		}

		public static unsafe void TexCoordPointerListIBM(Int32 size, TexCoordPointerType type, Int32 stride, IntPtr[] pointer, Int32 ptrstride)
		{
			fixed (IntPtr* ptr737 = &pointer[0]) { glTexCoordPointerListIBM(size, (uint)type, stride, new IntPtr(ptr737), ptrstride); } 
		}

		public static unsafe void VertexPointerListIBM(Int32 size, VertexPointerType type, Int32 stride, IntPtr[] pointer, Int32 ptrstride)
		{
			fixed (IntPtr* ptr738 = &pointer[0]) { glVertexPointerListIBM(size, (uint)type, stride, new IntPtr(ptr738), ptrstride); } 
		}

		public static unsafe void TbufferMask3DFX(UInt32 mask)
		{
			glTbufferMask3DFX(mask);
		}

		public static unsafe void SampleMaskEXT(float val, bool invert)
		{
			glSampleMaskEXT(val, invert ? ((byte)1) : ((byte)0));
		}

		public static unsafe void SamplePatternEXT(GLEnum pattern)
		{
			glSamplePatternEXT((uint)pattern);
		}

		public static unsafe void TextureColorMaskSGIS(bool red, bool green, bool blue, bool alpha)
		{
			glTextureColorMaskSGIS(red ? ((byte)1) : ((byte)0), green ? ((byte)1) : ((byte)0), blue ? ((byte)1) : ((byte)0), alpha ? ((byte)1) : ((byte)0));
		}

		public static unsafe void IglooInterfaceSGIX(GLEnum pname, IntPtr parameters)
		{
			glIglooInterfaceSGIX((uint)pname, parameters);
		}

		public static unsafe void DeleteFencesNV(Int32 n, UInt32[] fences)
		{
			fixed (UInt32* ptr739 = &fences[0]) { glDeleteFencesNV(n, new IntPtr(ptr739)); } 
		}

		public static unsafe void GenFencesNV(Int32 n, [OutAttribute] UInt32[] fences)
		{
			fixed (UInt32* optr740 = fences) { glGenFencesNV(n, optr740); } 
		}

		public static unsafe bool IsFenceNV(UInt32 fence)
		{
			return (glIsFenceNV(fence) == 1);
		}

		public static unsafe bool TestFenceNV(UInt32 fence)
		{
			return (glTestFenceNV(fence) == 1);
		}

		public static unsafe void GetFenceivNV(UInt32 fence, GLEnum pname, [OutAttribute] Int32[] parameters)
		{
			fixed (Int32* optr741 = parameters) { glGetFenceivNV(fence, (uint)pname, optr741); } 
		}

		public static unsafe void FinishFenceNV(UInt32 fence)
		{
			glFinishFenceNV(fence);
		}

		public static unsafe void SetFenceNV(UInt32 fence, GLEnum condition)
		{
			glSetFenceNV(fence, (uint)condition);
		}

		public static unsafe void MapControlPointsNV(GLEnum target, UInt32 index, GLEnum type, Int32 ustride, Int32 vstride, Int32 uorder, Int32 vorder, bool packed, IntPtr points)
		{
			glMapControlPointsNV((uint)target, index, (uint)type, ustride, vstride, uorder, vorder, packed ? ((byte)1) : ((byte)0), points);
		}

		public static unsafe void MapParameterivNV(GLEnum target, GLEnum pname, Int32[] parameters)
		{
			fixed (Int32* ptr742 = &parameters[0]) { glMapParameterivNV((uint)target, (uint)pname, new IntPtr(ptr742)); } 
		}

		public static unsafe void MapParameterfvNV(GLEnum target, GLEnum pname, float[] parameters)
		{
			fixed (float* ptr743 = &parameters[0]) { glMapParameterfvNV((uint)target, (uint)pname, new IntPtr(ptr743)); } 
		}

		public static unsafe void GetMapControlPointsNV(GLEnum target, UInt32 index, GLEnum type, Int32 ustride, Int32 vstride, bool packed, [OutAttribute] IntPtr points)
		{
			glGetMapControlPointsNV((uint)target, index, (uint)type, ustride, vstride, packed ? ((byte)1) : ((byte)0), points);
		}

		public static unsafe void GetMapParameterivNV(GLEnum target, GLEnum pname, [OutAttribute] Int32[] parameters)
		{
			fixed (Int32* optr744 = parameters) { glGetMapParameterivNV((uint)target, (uint)pname, optr744); } 
		}

		public static unsafe void GetMapParameterfvNV(GLEnum target, GLEnum pname, [OutAttribute] float[] parameters)
		{
			fixed (float* optr745 = parameters) { glGetMapParameterfvNV((uint)target, (uint)pname, optr745); } 
		}

		public static unsafe void GetMapAttribParameterivNV(GLEnum target, UInt32 index, GLEnum pname, [OutAttribute] Int32[] parameters)
		{
			fixed (Int32* optr746 = parameters) { glGetMapAttribParameterivNV((uint)target, index, (uint)pname, optr746); } 
		}

		public static unsafe void GetMapAttribParameterfvNV(GLEnum target, UInt32 index, GLEnum pname, [OutAttribute] float[] parameters)
		{
			fixed (float* optr747 = parameters) { glGetMapAttribParameterfvNV((uint)target, index, (uint)pname, optr747); } 
		}

		public static unsafe void EvalMapsNV(GLEnum target, GLEnum mode)
		{
			glEvalMapsNV((uint)target, (uint)mode);
		}

		public static unsafe void CombinerStageParameterfvNV(GLEnum stage, GLEnum pname, float[] parameters)
		{
			fixed (float* ptr748 = &parameters[0]) { glCombinerStageParameterfvNV((uint)stage, (uint)pname, new IntPtr(ptr748)); } 
		}

		public static unsafe void GetCombinerStageParameterfvNV(GLEnum stage, GLEnum pname, [OutAttribute] float[] parameters)
		{
			fixed (float* optr749 = parameters) { glGetCombinerStageParameterfvNV((uint)stage, (uint)pname, optr749); } 
		}

		public static unsafe bool AreProgramsResidentNV(Int32 n, UInt32[] programs, [OutAttribute] bool[] residences)
		{
			bool retVal;
			byte[] btr751 = new byte[1];
			fixed (byte* optr751 = btr751) { fixed (UInt32* ptr750 = &programs[0]) { retVal = (glAreProgramsResidentNV(n, new IntPtr(ptr750), optr751) == 1); }  }
			residences = new bool[btr751.Length];
			for (int i751 = 0; i751< residences.Length; i751++)
				residences[i751] = (btr751[i751] == 1);
			 
			return retVal;
		}

		public static unsafe void BindProgramNV(GLEnum target, UInt32 id)
		{
			glBindProgramNV((uint)target, id);
		}

		public static unsafe void DeleteProgramsNV(Int32 n, UInt32[] programs)
		{
			fixed (UInt32* ptr752 = &programs[0]) { glDeleteProgramsNV(n, new IntPtr(ptr752)); } 
		}

		public static unsafe void ExecuteProgramNV(GLEnum target, UInt32 id, float[] parameters)
		{
			fixed (float* ptr753 = &parameters[0]) { glExecuteProgramNV((uint)target, id, new IntPtr(ptr753)); } 
		}

		public static unsafe void GenProgramsNV(Int32 n, [OutAttribute] UInt32[] programs)
		{
			fixed (UInt32* optr754 = programs) { glGenProgramsNV(n, optr754); } 
		}

		public static unsafe void GetProgramParameterdvNV(GLEnum target, UInt32 index, GLEnum pname, [OutAttribute] double[] parameters)
		{
			fixed (double* optr755 = parameters) { glGetProgramParameterdvNV((uint)target, index, (uint)pname, optr755); } 
		}

		public static unsafe void GetProgramParameterfvNV(GLEnum target, UInt32 index, GLEnum pname, [OutAttribute] float[] parameters)
		{
			fixed (float* optr756 = parameters) { glGetProgramParameterfvNV((uint)target, index, (uint)pname, optr756); } 
		}

		public static unsafe void GetProgramivNV(UInt32 id, GLEnum pname, [OutAttribute] Int32[] parameters)
		{
			fixed (Int32* optr757 = parameters) { glGetProgramivNV(id, (uint)pname, optr757); } 
		}

		public static unsafe void GetProgramStringNV(UInt32 id, GLEnum pname, [OutAttribute] byte[] program)
		{
			fixed (byte* optr758 = program) { glGetProgramStringNV(id, (uint)pname, optr758); } 
		}

		public static unsafe void GetTrackMatrixivNV(GLEnum target, UInt32 address, GLEnum pname, [OutAttribute] Int32[] parameters)
		{
			fixed (Int32* optr759 = parameters) { glGetTrackMatrixivNV((uint)target, address, (uint)pname, optr759); } 
		}

		public static unsafe void GetVertexAttribdvNV(UInt32 index, GLEnum pname, [OutAttribute] double[] parameters)
		{
			fixed (double* optr760 = parameters) { glGetVertexAttribdvNV(index, (uint)pname, optr760); } 
		}

		public static unsafe void GetVertexAttribfvNV(UInt32 index, GLEnum pname, [OutAttribute] float[] parameters)
		{
			fixed (float* optr761 = parameters) { glGetVertexAttribfvNV(index, (uint)pname, optr761); } 
		}

		public static unsafe void GetVertexAttribivNV(UInt32 index, GLEnum pname, [OutAttribute] Int32[] parameters)
		{
			fixed (Int32* optr762 = parameters) { glGetVertexAttribivNV(index, (uint)pname, optr762); } 
		}

		public static unsafe void GetVertexAttribPointervNV(UInt32 index, GLEnum pname, [OutAttribute] IntPtr[] pointer)
		{
			fixed (IntPtr* optr763 = pointer) { glGetVertexAttribPointervNV(index, (uint)pname, optr763); } 
		}

		public static unsafe bool IsProgramNV(UInt32 id)
		{
			return (glIsProgramNV(id) == 1);
		}

		public static unsafe void LoadProgramNV(GLEnum target, UInt32 id, Int32 len, byte[] program)
		{
			fixed (byte* ptr764 = &program[0]) { glLoadProgramNV((uint)target, id, len, new IntPtr(ptr764)); } 
		}

		public static unsafe void ProgramParameter4dNV(GLEnum target, UInt32 index, double x, double y, double z, double w)
		{
			glProgramParameter4dNV((uint)target, index, x, y, z, w);
		}

		public static unsafe void ProgramParameter4dvNV(GLEnum target, UInt32 index, double[] v)
		{
			fixed (double* ptr765 = &v[0]) { glProgramParameter4dvNV((uint)target, index, new IntPtr(ptr765)); } 
		}

		public static unsafe void ProgramParameter4fNV(GLEnum target, UInt32 index, float x, float y, float z, float w)
		{
			glProgramParameter4fNV((uint)target, index, x, y, z, w);
		}

		public static unsafe void ProgramParameter4fvNV(GLEnum target, UInt32 index, float[] v)
		{
			fixed (float* ptr766 = &v[0]) { glProgramParameter4fvNV((uint)target, index, new IntPtr(ptr766)); } 
		}

		public static unsafe void ProgramParameters4dvNV(GLEnum target, UInt32 index, UInt32 count, double[] v)
		{
			fixed (double* ptr767 = &v[0]) { glProgramParameters4dvNV((uint)target, index, count, new IntPtr(ptr767)); } 
		}

		public static unsafe void ProgramParameters4fvNV(GLEnum target, UInt32 index, UInt32 count, float[] v)
		{
			fixed (float* ptr768 = &v[0]) { glProgramParameters4fvNV((uint)target, index, count, new IntPtr(ptr768)); } 
		}

		public static unsafe void RequestResidentProgramsNV(Int32 n, UInt32[] programs)
		{
			fixed (UInt32* ptr769 = &programs[0]) { glRequestResidentProgramsNV(n, new IntPtr(ptr769)); } 
		}

		public static unsafe void TrackMatrixNV(GLEnum target, UInt32 address, GLEnum matrix, GLEnum transform)
		{
			glTrackMatrixNV((uint)target, address, (uint)matrix, (uint)transform);
		}

		public static unsafe void VertexAttribPointerNV(UInt32 index, Int32 fsize, GLEnum type, Int32 stride, IntPtr pointer)
		{
			glVertexAttribPointerNV(index, fsize, (uint)type, stride, pointer);
		}

		public static unsafe void VertexAttrib1dNV(UInt32 index, double x)
		{
			glVertexAttrib1dNV(index, x);
		}

		public static unsafe void VertexAttrib1dvNV(UInt32 index, double[] v)
		{
			fixed (double* ptr770 = &v[0]) { glVertexAttrib1dvNV(index, new IntPtr(ptr770)); } 
		}

		public static unsafe void VertexAttrib1fNV(UInt32 index, float x)
		{
			glVertexAttrib1fNV(index, x);
		}

		public static unsafe void VertexAttrib1fvNV(UInt32 index, float[] v)
		{
			fixed (float* ptr771 = &v[0]) { glVertexAttrib1fvNV(index, new IntPtr(ptr771)); } 
		}

		public static unsafe void VertexAttrib1sNV(UInt32 index, Int16 x)
		{
			glVertexAttrib1sNV(index, x);
		}

		public static unsafe void VertexAttrib1svNV(UInt32 index, Int16[] v)
		{
			fixed (Int16* ptr772 = &v[0]) { glVertexAttrib1svNV(index, new IntPtr(ptr772)); } 
		}

		public static unsafe void VertexAttrib2dNV(UInt32 index, double x, double y)
		{
			glVertexAttrib2dNV(index, x, y);
		}

		public static unsafe void VertexAttrib2dvNV(UInt32 index, double[] v)
		{
			fixed (double* ptr773 = &v[0]) { glVertexAttrib2dvNV(index, new IntPtr(ptr773)); } 
		}

		public static unsafe void VertexAttrib2fNV(UInt32 index, float x, float y)
		{
			glVertexAttrib2fNV(index, x, y);
		}

		public static unsafe void VertexAttrib2fvNV(UInt32 index, float[] v)
		{
			fixed (float* ptr774 = &v[0]) { glVertexAttrib2fvNV(index, new IntPtr(ptr774)); } 
		}

		public static unsafe void VertexAttrib2sNV(UInt32 index, Int16 x, Int16 y)
		{
			glVertexAttrib2sNV(index, x, y);
		}

		public static unsafe void VertexAttrib2svNV(UInt32 index, Int16[] v)
		{
			fixed (Int16* ptr775 = &v[0]) { glVertexAttrib2svNV(index, new IntPtr(ptr775)); } 
		}

		public static unsafe void VertexAttrib3dNV(UInt32 index, double x, double y, double z)
		{
			glVertexAttrib3dNV(index, x, y, z);
		}

		public static unsafe void VertexAttrib3dvNV(UInt32 index, double[] v)
		{
			fixed (double* ptr776 = &v[0]) { glVertexAttrib3dvNV(index, new IntPtr(ptr776)); } 
		}

		public static unsafe void VertexAttrib3fNV(UInt32 index, float x, float y, float z)
		{
			glVertexAttrib3fNV(index, x, y, z);
		}

		public static unsafe void VertexAttrib3fvNV(UInt32 index, float[] v)
		{
			fixed (float* ptr777 = &v[0]) { glVertexAttrib3fvNV(index, new IntPtr(ptr777)); } 
		}

		public static unsafe void VertexAttrib3sNV(UInt32 index, Int16 x, Int16 y, Int16 z)
		{
			glVertexAttrib3sNV(index, x, y, z);
		}

		public static unsafe void VertexAttrib3svNV(UInt32 index, Int16[] v)
		{
			fixed (Int16* ptr778 = &v[0]) { glVertexAttrib3svNV(index, new IntPtr(ptr778)); } 
		}

		public static unsafe void VertexAttrib4dNV(UInt32 index, double x, double y, double z, double w)
		{
			glVertexAttrib4dNV(index, x, y, z, w);
		}

		public static unsafe void VertexAttrib4dvNV(UInt32 index, double[] v)
		{
			fixed (double* ptr779 = &v[0]) { glVertexAttrib4dvNV(index, new IntPtr(ptr779)); } 
		}

		public static unsafe void VertexAttrib4fNV(UInt32 index, float x, float y, float z, float w)
		{
			glVertexAttrib4fNV(index, x, y, z, w);
		}

		public static unsafe void VertexAttrib4fvNV(UInt32 index, float[] v)
		{
			fixed (float* ptr780 = &v[0]) { glVertexAttrib4fvNV(index, new IntPtr(ptr780)); } 
		}

		public static unsafe void VertexAttrib4sNV(UInt32 index, Int16 x, Int16 y, Int16 z, Int16 w)
		{
			glVertexAttrib4sNV(index, x, y, z, w);
		}

		public static unsafe void VertexAttrib4svNV(UInt32 index, Int16[] v)
		{
			fixed (Int16* ptr781 = &v[0]) { glVertexAttrib4svNV(index, new IntPtr(ptr781)); } 
		}

		public static unsafe void VertexAttrib4ubNV(UInt32 index, byte x, byte y, byte z, byte w)
		{
			glVertexAttrib4ubNV(index, x, y, z, w);
		}

		public static unsafe void VertexAttrib4ubvNV(UInt32 index, byte[] v)
		{
			fixed (byte* ptr782 = &v[0]) { glVertexAttrib4ubvNV(index, new IntPtr(ptr782)); } 
		}

		public static unsafe void VertexAttribs1dvNV(UInt32 index, Int32 count, double[] v)
		{
			fixed (double* ptr783 = &v[0]) { glVertexAttribs1dvNV(index, count, new IntPtr(ptr783)); } 
		}

		public static unsafe void VertexAttribs1fvNV(UInt32 index, Int32 count, float[] v)
		{
			fixed (float* ptr784 = &v[0]) { glVertexAttribs1fvNV(index, count, new IntPtr(ptr784)); } 
		}

		public static unsafe void VertexAttribs1svNV(UInt32 index, Int32 count, Int16[] v)
		{
			fixed (Int16* ptr785 = &v[0]) { glVertexAttribs1svNV(index, count, new IntPtr(ptr785)); } 
		}

		public static unsafe void VertexAttribs2dvNV(UInt32 index, Int32 count, double[] v)
		{
			fixed (double* ptr786 = &v[0]) { glVertexAttribs2dvNV(index, count, new IntPtr(ptr786)); } 
		}

		public static unsafe void VertexAttribs2fvNV(UInt32 index, Int32 count, float[] v)
		{
			fixed (float* ptr787 = &v[0]) { glVertexAttribs2fvNV(index, count, new IntPtr(ptr787)); } 
		}

		public static unsafe void VertexAttribs2svNV(UInt32 index, Int32 count, Int16[] v)
		{
			fixed (Int16* ptr788 = &v[0]) { glVertexAttribs2svNV(index, count, new IntPtr(ptr788)); } 
		}

		public static unsafe void VertexAttribs3dvNV(UInt32 index, Int32 count, double[] v)
		{
			fixed (double* ptr789 = &v[0]) { glVertexAttribs3dvNV(index, count, new IntPtr(ptr789)); } 
		}

		public static unsafe void VertexAttribs3fvNV(UInt32 index, Int32 count, float[] v)
		{
			fixed (float* ptr790 = &v[0]) { glVertexAttribs3fvNV(index, count, new IntPtr(ptr790)); } 
		}

		public static unsafe void VertexAttribs3svNV(UInt32 index, Int32 count, Int16[] v)
		{
			fixed (Int16* ptr791 = &v[0]) { glVertexAttribs3svNV(index, count, new IntPtr(ptr791)); } 
		}

		public static unsafe void VertexAttribs4dvNV(UInt32 index, Int32 count, double[] v)
		{
			fixed (double* ptr792 = &v[0]) { glVertexAttribs4dvNV(index, count, new IntPtr(ptr792)); } 
		}

		public static unsafe void VertexAttribs4fvNV(UInt32 index, Int32 count, float[] v)
		{
			fixed (float* ptr793 = &v[0]) { glVertexAttribs4fvNV(index, count, new IntPtr(ptr793)); } 
		}

		public static unsafe void VertexAttribs4svNV(UInt32 index, Int32 count, Int16[] v)
		{
			fixed (Int16* ptr794 = &v[0]) { glVertexAttribs4svNV(index, count, new IntPtr(ptr794)); } 
		}

		public static unsafe void VertexAttribs4ubvNV(UInt32 index, Int32 count, byte[] v)
		{
			fixed (byte* ptr795 = &v[0]) { glVertexAttribs4ubvNV(index, count, new IntPtr(ptr795)); } 
		}

		public static unsafe void TexBumpParameterivATI(GLEnum pname, Int32[] param)
		{
			fixed (Int32* ptr796 = &param[0]) { glTexBumpParameterivATI((uint)pname, new IntPtr(ptr796)); } 
		}

		public static unsafe void TexBumpParameterfvATI(GLEnum pname, float[] param)
		{
			fixed (float* ptr797 = &param[0]) { glTexBumpParameterfvATI((uint)pname, new IntPtr(ptr797)); } 
		}

		public static unsafe void GetTexBumpParameterivATI(GLEnum pname, [OutAttribute] Int32[] param)
		{
			fixed (Int32* optr798 = param) { glGetTexBumpParameterivATI((uint)pname, optr798); } 
		}

		public static unsafe void GetTexBumpParameterfvATI(GLEnum pname, [OutAttribute] float[] param)
		{
			fixed (float* optr799 = param) { glGetTexBumpParameterfvATI((uint)pname, optr799); } 
		}

		public static unsafe UInt32 GenFragmentShadersATI(UInt32 range)
		{
			return glGenFragmentShadersATI(range);
		}

		public static unsafe void BindFragmentShaderATI(UInt32 id)
		{
			glBindFragmentShaderATI(id);
		}

		public static unsafe void DeleteFragmentShaderATI(UInt32 id)
		{
			glDeleteFragmentShaderATI(id);
		}

		public static unsafe void BeginFragmentShaderATI()
		{
			glBeginFragmentShaderATI();
		}

		public static unsafe void EndFragmentShaderATI()
		{
			glEndFragmentShaderATI();
		}

		public static unsafe void PassTexCoordATI(UInt32 dst, UInt32 coord, GLEnum swizzle)
		{
			glPassTexCoordATI(dst, coord, (uint)swizzle);
		}

		public static unsafe void SampleMapATI(UInt32 dst, UInt32 interp, GLEnum swizzle)
		{
			glSampleMapATI(dst, interp, (uint)swizzle);
		}

		public static unsafe void ColorFragmentOp1ATI(GLEnum op, UInt32 dst, UInt32 dstMask, UInt32 dstMod, UInt32 arg1, UInt32 arg1Rep, UInt32 arg1Mod)
		{
			glColorFragmentOp1ATI((uint)op, dst, dstMask, dstMod, arg1, arg1Rep, arg1Mod);
		}

		public static unsafe void ColorFragmentOp2ATI(GLEnum op, UInt32 dst, UInt32 dstMask, UInt32 dstMod, UInt32 arg1, UInt32 arg1Rep, UInt32 arg1Mod, UInt32 arg2, UInt32 arg2Rep, UInt32 arg2Mod)
		{
			glColorFragmentOp2ATI((uint)op, dst, dstMask, dstMod, arg1, arg1Rep, arg1Mod, arg2, arg2Rep, arg2Mod);
		}

		public static unsafe void ColorFragmentOp3ATI(GLEnum op, UInt32 dst, UInt32 dstMask, UInt32 dstMod, UInt32 arg1, UInt32 arg1Rep, UInt32 arg1Mod, UInt32 arg2, UInt32 arg2Rep, UInt32 arg2Mod, UInt32 arg3, UInt32 arg3Rep, UInt32 arg3Mod)
		{
			glColorFragmentOp3ATI((uint)op, dst, dstMask, dstMod, arg1, arg1Rep, arg1Mod, arg2, arg2Rep, arg2Mod, arg3, arg3Rep, arg3Mod);
		}

		public static unsafe void AlphaFragmentOp1ATI(GLEnum op, UInt32 dst, UInt32 dstMod, UInt32 arg1, UInt32 arg1Rep, UInt32 arg1Mod)
		{
			glAlphaFragmentOp1ATI((uint)op, dst, dstMod, arg1, arg1Rep, arg1Mod);
		}

		public static unsafe void AlphaFragmentOp2ATI(GLEnum op, UInt32 dst, UInt32 dstMod, UInt32 arg1, UInt32 arg1Rep, UInt32 arg1Mod, UInt32 arg2, UInt32 arg2Rep, UInt32 arg2Mod)
		{
			glAlphaFragmentOp2ATI((uint)op, dst, dstMod, arg1, arg1Rep, arg1Mod, arg2, arg2Rep, arg2Mod);
		}

		public static unsafe void AlphaFragmentOp3ATI(GLEnum op, UInt32 dst, UInt32 dstMod, UInt32 arg1, UInt32 arg1Rep, UInt32 arg1Mod, UInt32 arg2, UInt32 arg2Rep, UInt32 arg2Mod, UInt32 arg3, UInt32 arg3Rep, UInt32 arg3Mod)
		{
			glAlphaFragmentOp3ATI((uint)op, dst, dstMod, arg1, arg1Rep, arg1Mod, arg2, arg2Rep, arg2Mod, arg3, arg3Rep, arg3Mod);
		}

		public static unsafe void SetFragmentShaderConstantATI(UInt32 dst, float[] val)
		{
			fixed (float* ptr800 = &val[0]) { glSetFragmentShaderConstantATI(dst, new IntPtr(ptr800)); } 
		}

		public static unsafe void PNTrianglesiATI(GLEnum pname, Int32 param)
		{
			glPNTrianglesiATI((uint)pname, param);
		}

		public static unsafe void PNTrianglesfATI(GLEnum pname, float param)
		{
			glPNTrianglesfATI((uint)pname, param);
		}

		public static unsafe UInt32 NewObjectBufferATI(Int32 size, IntPtr pointer, GLEnum usage)
		{
			return glNewObjectBufferATI(size, pointer, (uint)usage);
		}

		public static unsafe bool IsObjectBufferATI(UInt32 buffer)
		{
			return (glIsObjectBufferATI(buffer) == 1);
		}

		public static unsafe void UpdateObjectBufferATI(UInt32 buffer, UInt32 offset, Int32 size, IntPtr pointer, GLEnum preserve)
		{
			glUpdateObjectBufferATI(buffer, offset, size, pointer, (uint)preserve);
		}

		public static unsafe void GetObjectBufferfvATI(UInt32 buffer, GLEnum pname, [OutAttribute] float[] parameters)
		{
			fixed (float* optr801 = parameters) { glGetObjectBufferfvATI(buffer, (uint)pname, optr801); } 
		}

		public static unsafe void GetObjectBufferivATI(UInt32 buffer, GLEnum pname, [OutAttribute] Int32[] parameters)
		{
			fixed (Int32* optr802 = parameters) { glGetObjectBufferivATI(buffer, (uint)pname, optr802); } 
		}

		public static unsafe void FreeObjectBufferATI(UInt32 buffer)
		{
			glFreeObjectBufferATI(buffer);
		}

		public static unsafe void ArrayObjectATI(EnableCap array, Int32 size, GLEnum type, Int32 stride, UInt32 buffer, UInt32 offset)
		{
			glArrayObjectATI((uint)array, size, (uint)type, stride, buffer, offset);
		}

		public static unsafe void GetArrayObjectfvATI(EnableCap array, GLEnum pname, [OutAttribute] float[] parameters)
		{
			fixed (float* optr803 = parameters) { glGetArrayObjectfvATI((uint)array, (uint)pname, optr803); } 
		}

		public static unsafe void GetArrayObjectivATI(EnableCap array, GLEnum pname, [OutAttribute] Int32[] parameters)
		{
			fixed (Int32* optr804 = parameters) { glGetArrayObjectivATI((uint)array, (uint)pname, optr804); } 
		}

		public static unsafe void VariantArrayObjectATI(UInt32 id, GLEnum type, Int32 stride, UInt32 buffer, UInt32 offset)
		{
			glVariantArrayObjectATI(id, (uint)type, stride, buffer, offset);
		}

		public static unsafe void GetVariantArrayObjectfvATI(UInt32 id, GLEnum pname, [OutAttribute] float[] parameters)
		{
			fixed (float* optr805 = parameters) { glGetVariantArrayObjectfvATI(id, (uint)pname, optr805); } 
		}

		public static unsafe void GetVariantArrayObjectivATI(UInt32 id, GLEnum pname, [OutAttribute] Int32[] parameters)
		{
			fixed (Int32* optr806 = parameters) { glGetVariantArrayObjectivATI(id, (uint)pname, optr806); } 
		}

		public static unsafe void BeginVertexShaderEXT()
		{
			glBeginVertexShaderEXT();
		}

		public static unsafe void EndVertexShaderEXT()
		{
			glEndVertexShaderEXT();
		}

		public static unsafe void BindVertexShaderEXT(UInt32 id)
		{
			glBindVertexShaderEXT(id);
		}

		public static unsafe UInt32 GenVertexShadersEXT(UInt32 range)
		{
			return glGenVertexShadersEXT(range);
		}

		public static unsafe void DeleteVertexShaderEXT(UInt32 id)
		{
			glDeleteVertexShaderEXT(id);
		}

		public static unsafe void ShaderOp1EXT(GLEnum op, UInt32 res, UInt32 arg1)
		{
			glShaderOp1EXT((uint)op, res, arg1);
		}

		public static unsafe void ShaderOp2EXT(GLEnum op, UInt32 res, UInt32 arg1, UInt32 arg2)
		{
			glShaderOp2EXT((uint)op, res, arg1, arg2);
		}

		public static unsafe void ShaderOp3EXT(GLEnum op, UInt32 res, UInt32 arg1, UInt32 arg2, UInt32 arg3)
		{
			glShaderOp3EXT((uint)op, res, arg1, arg2, arg3);
		}

		public static unsafe void SwizzleEXT(UInt32 res, UInt32 input, GLEnum outX, GLEnum outY, GLEnum outZ, GLEnum outW)
		{
			glSwizzleEXT(res, input, (uint)outX, (uint)outY, (uint)outZ, (uint)outW);
		}

		public static unsafe void WriteMaskEXT(UInt32 res, UInt32 input, GLEnum outX, GLEnum outY, GLEnum outZ, GLEnum outW)
		{
			glWriteMaskEXT(res, input, (uint)outX, (uint)outY, (uint)outZ, (uint)outW);
		}

		public static unsafe void InsertComponentEXT(UInt32 res, UInt32 src, UInt32 num)
		{
			glInsertComponentEXT(res, src, num);
		}

		public static unsafe void ExtractComponentEXT(UInt32 res, UInt32 src, UInt32 num)
		{
			glExtractComponentEXT(res, src, num);
		}

		public static unsafe UInt32 GenSymbolsEXT(GLEnum datatype, GLEnum storagetype, GLEnum range, UInt32 components)
		{
			return glGenSymbolsEXT((uint)datatype, (uint)storagetype, (uint)range, components);
		}

		public static unsafe void SetInvariantEXT(UInt32 id, GLEnum type, IntPtr addr)
		{
			glSetInvariantEXT(id, (uint)type, addr);
		}

		public static unsafe void SetLocalConstantEXT(UInt32 id, GLEnum type, IntPtr addr)
		{
			glSetLocalConstantEXT(id, (uint)type, addr);
		}

		public static unsafe void VariantbvEXT(UInt32 id, SByte[] addr)
		{
			fixed (SByte* ptr807 = &addr[0]) { glVariantbvEXT(id, new IntPtr(ptr807)); } 
		}

		public static unsafe void VariantsvEXT(UInt32 id, Int16[] addr)
		{
			fixed (Int16* ptr808 = &addr[0]) { glVariantsvEXT(id, new IntPtr(ptr808)); } 
		}

		public static unsafe void VariantivEXT(UInt32 id, Int32[] addr)
		{
			fixed (Int32* ptr809 = &addr[0]) { glVariantivEXT(id, new IntPtr(ptr809)); } 
		}

		public static unsafe void VariantfvEXT(UInt32 id, float[] addr)
		{
			fixed (float* ptr810 = &addr[0]) { glVariantfvEXT(id, new IntPtr(ptr810)); } 
		}

		public static unsafe void VariantdvEXT(UInt32 id, double[] addr)
		{
			fixed (double* ptr811 = &addr[0]) { glVariantdvEXT(id, new IntPtr(ptr811)); } 
		}

		public static unsafe void VariantubvEXT(UInt32 id, byte[] addr)
		{
			fixed (byte* ptr812 = &addr[0]) { glVariantubvEXT(id, new IntPtr(ptr812)); } 
		}

		public static unsafe void VariantusvEXT(UInt32 id, UInt16[] addr)
		{
			fixed (UInt16* ptr813 = &addr[0]) { glVariantusvEXT(id, new IntPtr(ptr813)); } 
		}

		public static unsafe void VariantuivEXT(UInt32 id, UInt32[] addr)
		{
			fixed (UInt32* ptr814 = &addr[0]) { glVariantuivEXT(id, new IntPtr(ptr814)); } 
		}

		public static unsafe void VariantPointerEXT(UInt32 id, GLEnum type, UInt32 stride, IntPtr addr)
		{
			glVariantPointerEXT(id, (uint)type, stride, addr);
		}

		public static unsafe void EnableVariantClientStateEXT(UInt32 id)
		{
			glEnableVariantClientStateEXT(id);
		}

		public static unsafe void DisableVariantClientStateEXT(UInt32 id)
		{
			glDisableVariantClientStateEXT(id);
		}

		public static unsafe UInt32 BindLightParameterEXT(LightName light, LightParameter val)
		{
			return glBindLightParameterEXT((uint)light, (uint)val);
		}

		public static unsafe UInt32 BindMaterialParameterEXT(MaterialFace face, MaterialParameter val)
		{
			return glBindMaterialParameterEXT((uint)face, (uint)val);
		}

		public static unsafe UInt32 BindTexGenParameterEXT(GLEnum unit, TextureCoordName coord, TextureGenParameter val)
		{
			return glBindTexGenParameterEXT((uint)unit, (uint)coord, (uint)val);
		}

		public static unsafe UInt32 BindTextureUnitParameterEXT(GLEnum unit, GLEnum val)
		{
			return glBindTextureUnitParameterEXT((uint)unit, (uint)val);
		}

		public static unsafe UInt32 BindParameterEXT(GLEnum val)
		{
			return glBindParameterEXT((uint)val);
		}

		public static unsafe bool IsVariantEnabledEXT(UInt32 id, GLEnum cap)
		{
			return (glIsVariantEnabledEXT(id, (uint)cap) == 1);
		}

		public static unsafe void GetVariantBooleanvEXT(UInt32 id, GLEnum val, [OutAttribute] bool[] data)
		{
			byte[] btr815 = new byte[1];
			fixed (byte* optr815 = btr815) { glGetVariantBooleanvEXT(id, (uint)val, optr815); }
			data = new bool[btr815.Length];
			for (int i815 = 0; i815< data.Length; i815++)
				data[i815] = (btr815[i815] == 1);
			 
		}

		public static unsafe void GetVariantIntegervEXT(UInt32 id, GLEnum val, [OutAttribute] Int32[] data)
		{
			fixed (Int32* optr816 = data) { glGetVariantIntegervEXT(id, (uint)val, optr816); } 
		}

		public static unsafe void GetVariantFloatvEXT(UInt32 id, GLEnum val, [OutAttribute] float[] data)
		{
			fixed (float* optr817 = data) { glGetVariantFloatvEXT(id, (uint)val, optr817); } 
		}

		public static unsafe void GetVariantPointervEXT(UInt32 id, GLEnum val, [OutAttribute] IntPtr[] data)
		{
			fixed (IntPtr* optr818 = data) { glGetVariantPointervEXT(id, (uint)val, optr818); } 
		}

		public static unsafe void GetInvariantBooleanvEXT(UInt32 id, GLEnum val, [OutAttribute] bool[] data)
		{
			byte[] btr819 = new byte[1];
			fixed (byte* optr819 = btr819) { glGetInvariantBooleanvEXT(id, (uint)val, optr819); }
			data = new bool[btr819.Length];
			for (int i819 = 0; i819< data.Length; i819++)
				data[i819] = (btr819[i819] == 1);
			 
		}

		public static unsafe void GetInvariantIntegervEXT(UInt32 id, GLEnum val, [OutAttribute] Int32[] data)
		{
			fixed (Int32* optr820 = data) { glGetInvariantIntegervEXT(id, (uint)val, optr820); } 
		}

		public static unsafe void GetInvariantFloatvEXT(UInt32 id, GLEnum val, [OutAttribute] float[] data)
		{
			fixed (float* optr821 = data) { glGetInvariantFloatvEXT(id, (uint)val, optr821); } 
		}

		public static unsafe void GetLocalConstantBooleanvEXT(UInt32 id, GLEnum val, [OutAttribute] bool[] data)
		{
			byte[] btr822 = new byte[1];
			fixed (byte* optr822 = btr822) { glGetLocalConstantBooleanvEXT(id, (uint)val, optr822); }
			data = new bool[btr822.Length];
			for (int i822 = 0; i822< data.Length; i822++)
				data[i822] = (btr822[i822] == 1);
			 
		}

		public static unsafe void GetLocalConstantIntegervEXT(UInt32 id, GLEnum val, [OutAttribute] Int32[] data)
		{
			fixed (Int32* optr823 = data) { glGetLocalConstantIntegervEXT(id, (uint)val, optr823); } 
		}

		public static unsafe void GetLocalConstantFloatvEXT(UInt32 id, GLEnum val, [OutAttribute] float[] data)
		{
			fixed (float* optr824 = data) { glGetLocalConstantFloatvEXT(id, (uint)val, optr824); } 
		}

		public static unsafe void VertexStream1sATI(GLEnum stream, Int16 x)
		{
			glVertexStream1sATI((uint)stream, x);
		}

		public static unsafe void VertexStream1svATI(GLEnum stream, Int16[] coords)
		{
			fixed (Int16* ptr825 = &coords[0]) { glVertexStream1svATI((uint)stream, new IntPtr(ptr825)); } 
		}

		public static unsafe void VertexStream1iATI(GLEnum stream, Int32 x)
		{
			glVertexStream1iATI((uint)stream, x);
		}

		public static unsafe void VertexStream1ivATI(GLEnum stream, Int32[] coords)
		{
			fixed (Int32* ptr826 = &coords[0]) { glVertexStream1ivATI((uint)stream, new IntPtr(ptr826)); } 
		}

		public static unsafe void VertexStream1fATI(GLEnum stream, float x)
		{
			glVertexStream1fATI((uint)stream, x);
		}

		public static unsafe void VertexStream1fvATI(GLEnum stream, float[] coords)
		{
			fixed (float* ptr827 = &coords[0]) { glVertexStream1fvATI((uint)stream, new IntPtr(ptr827)); } 
		}

		public static unsafe void VertexStream1dATI(GLEnum stream, double x)
		{
			glVertexStream1dATI((uint)stream, x);
		}

		public static unsafe void VertexStream1dvATI(GLEnum stream, double[] coords)
		{
			fixed (double* ptr828 = &coords[0]) { glVertexStream1dvATI((uint)stream, new IntPtr(ptr828)); } 
		}

		public static unsafe void VertexStream2sATI(GLEnum stream, Int16 x, Int16 y)
		{
			glVertexStream2sATI((uint)stream, x, y);
		}

		public static unsafe void VertexStream2svATI(GLEnum stream, Int16[] coords)
		{
			fixed (Int16* ptr829 = &coords[0]) { glVertexStream2svATI((uint)stream, new IntPtr(ptr829)); } 
		}

		public static unsafe void VertexStream2iATI(GLEnum stream, Int32 x, Int32 y)
		{
			glVertexStream2iATI((uint)stream, x, y);
		}

		public static unsafe void VertexStream2ivATI(GLEnum stream, Int32[] coords)
		{
			fixed (Int32* ptr830 = &coords[0]) { glVertexStream2ivATI((uint)stream, new IntPtr(ptr830)); } 
		}

		public static unsafe void VertexStream2fATI(GLEnum stream, float x, float y)
		{
			glVertexStream2fATI((uint)stream, x, y);
		}

		public static unsafe void VertexStream2fvATI(GLEnum stream, float[] coords)
		{
			fixed (float* ptr831 = &coords[0]) { glVertexStream2fvATI((uint)stream, new IntPtr(ptr831)); } 
		}

		public static unsafe void VertexStream2dATI(GLEnum stream, double x, double y)
		{
			glVertexStream2dATI((uint)stream, x, y);
		}

		public static unsafe void VertexStream2dvATI(GLEnum stream, double[] coords)
		{
			fixed (double* ptr832 = &coords[0]) { glVertexStream2dvATI((uint)stream, new IntPtr(ptr832)); } 
		}

		public static unsafe void VertexStream3sATI(GLEnum stream, Int16 x, Int16 y, Int16 z)
		{
			glVertexStream3sATI((uint)stream, x, y, z);
		}

		public static unsafe void VertexStream3svATI(GLEnum stream, Int16[] coords)
		{
			fixed (Int16* ptr833 = &coords[0]) { glVertexStream3svATI((uint)stream, new IntPtr(ptr833)); } 
		}

		public static unsafe void VertexStream3iATI(GLEnum stream, Int32 x, Int32 y, Int32 z)
		{
			glVertexStream3iATI((uint)stream, x, y, z);
		}

		public static unsafe void VertexStream3ivATI(GLEnum stream, Int32[] coords)
		{
			fixed (Int32* ptr834 = &coords[0]) { glVertexStream3ivATI((uint)stream, new IntPtr(ptr834)); } 
		}

		public static unsafe void VertexStream3fATI(GLEnum stream, float x, float y, float z)
		{
			glVertexStream3fATI((uint)stream, x, y, z);
		}

		public static unsafe void VertexStream3fvATI(GLEnum stream, float[] coords)
		{
			fixed (float* ptr835 = &coords[0]) { glVertexStream3fvATI((uint)stream, new IntPtr(ptr835)); } 
		}

		public static unsafe void VertexStream3dATI(GLEnum stream, double x, double y, double z)
		{
			glVertexStream3dATI((uint)stream, x, y, z);
		}

		public static unsafe void VertexStream3dvATI(GLEnum stream, double[] coords)
		{
			fixed (double* ptr836 = &coords[0]) { glVertexStream3dvATI((uint)stream, new IntPtr(ptr836)); } 
		}

		public static unsafe void VertexStream4sATI(GLEnum stream, Int16 x, Int16 y, Int16 z, Int16 w)
		{
			glVertexStream4sATI((uint)stream, x, y, z, w);
		}

		public static unsafe void VertexStream4svATI(GLEnum stream, Int16[] coords)
		{
			fixed (Int16* ptr837 = &coords[0]) { glVertexStream4svATI((uint)stream, new IntPtr(ptr837)); } 
		}

		public static unsafe void VertexStream4iATI(GLEnum stream, Int32 x, Int32 y, Int32 z, Int32 w)
		{
			glVertexStream4iATI((uint)stream, x, y, z, w);
		}

		public static unsafe void VertexStream4ivATI(GLEnum stream, Int32[] coords)
		{
			fixed (Int32* ptr838 = &coords[0]) { glVertexStream4ivATI((uint)stream, new IntPtr(ptr838)); } 
		}

		public static unsafe void VertexStream4fATI(GLEnum stream, float x, float y, float z, float w)
		{
			glVertexStream4fATI((uint)stream, x, y, z, w);
		}

		public static unsafe void VertexStream4fvATI(GLEnum stream, float[] coords)
		{
			fixed (float* ptr839 = &coords[0]) { glVertexStream4fvATI((uint)stream, new IntPtr(ptr839)); } 
		}

		public static unsafe void VertexStream4dATI(GLEnum stream, double x, double y, double z, double w)
		{
			glVertexStream4dATI((uint)stream, x, y, z, w);
		}

		public static unsafe void VertexStream4dvATI(GLEnum stream, double[] coords)
		{
			fixed (double* ptr840 = &coords[0]) { glVertexStream4dvATI((uint)stream, new IntPtr(ptr840)); } 
		}

		public static unsafe void NormalStream3bATI(GLEnum stream, SByte nx, SByte ny, SByte nz)
		{
			glNormalStream3bATI((uint)stream, nx, ny, nz);
		}

		public static unsafe void NormalStream3bvATI(GLEnum stream, SByte[] coords)
		{
			fixed (SByte* ptr841 = &coords[0]) { glNormalStream3bvATI((uint)stream, new IntPtr(ptr841)); } 
		}

		public static unsafe void NormalStream3sATI(GLEnum stream, Int16 nx, Int16 ny, Int16 nz)
		{
			glNormalStream3sATI((uint)stream, nx, ny, nz);
		}

		public static unsafe void NormalStream3svATI(GLEnum stream, Int16[] coords)
		{
			fixed (Int16* ptr842 = &coords[0]) { glNormalStream3svATI((uint)stream, new IntPtr(ptr842)); } 
		}

		public static unsafe void NormalStream3iATI(GLEnum stream, Int32 nx, Int32 ny, Int32 nz)
		{
			glNormalStream3iATI((uint)stream, nx, ny, nz);
		}

		public static unsafe void NormalStream3ivATI(GLEnum stream, Int32[] coords)
		{
			fixed (Int32* ptr843 = &coords[0]) { glNormalStream3ivATI((uint)stream, new IntPtr(ptr843)); } 
		}

		public static unsafe void NormalStream3fATI(GLEnum stream, float nx, float ny, float nz)
		{
			glNormalStream3fATI((uint)stream, nx, ny, nz);
		}

		public static unsafe void NormalStream3fvATI(GLEnum stream, float[] coords)
		{
			fixed (float* ptr844 = &coords[0]) { glNormalStream3fvATI((uint)stream, new IntPtr(ptr844)); } 
		}

		public static unsafe void NormalStream3dATI(GLEnum stream, double nx, double ny, double nz)
		{
			glNormalStream3dATI((uint)stream, nx, ny, nz);
		}

		public static unsafe void NormalStream3dvATI(GLEnum stream, double[] coords)
		{
			fixed (double* ptr845 = &coords[0]) { glNormalStream3dvATI((uint)stream, new IntPtr(ptr845)); } 
		}

		public static unsafe void ClientActiveVertexStreamATI(GLEnum stream)
		{
			glClientActiveVertexStreamATI((uint)stream);
		}

		public static unsafe void VertexBlendEnviATI(GLEnum pname, Int32 param)
		{
			glVertexBlendEnviATI((uint)pname, param);
		}

		public static unsafe void VertexBlendEnvfATI(GLEnum pname, float param)
		{
			glVertexBlendEnvfATI((uint)pname, param);
		}

		public static unsafe void ElementPointerATI(GLEnum type, IntPtr pointer)
		{
			glElementPointerATI((uint)type, pointer);
		}

		public static unsafe void DrawElementArrayATI(BeginMode mode, Int32 count)
		{
			glDrawElementArrayATI((uint)mode, count);
		}

		public static unsafe void DrawRangeElementArrayATI(BeginMode mode, UInt32 start, UInt32 end, Int32 count)
		{
			glDrawRangeElementArrayATI((uint)mode, start, end, count);
		}

		public static unsafe void DrawMeshArraysSUN(BeginMode mode, Int32 first, Int32 count, Int32 width)
		{
			glDrawMeshArraysSUN((uint)mode, first, count, width);
		}

		public static unsafe void GenOcclusionQueriesNV(Int32 n, [OutAttribute] UInt32[] ids)
		{
			fixed (UInt32* optr846 = ids) { glGenOcclusionQueriesNV(n, optr846); } 
		}

		public static unsafe void DeleteOcclusionQueriesNV(Int32 n, UInt32[] ids)
		{
			fixed (UInt32* ptr847 = &ids[0]) { glDeleteOcclusionQueriesNV(n, new IntPtr(ptr847)); } 
		}

		public static unsafe bool IsOcclusionQueryNV(UInt32 id)
		{
			return (glIsOcclusionQueryNV(id) == 1);
		}

		public static unsafe void BeginOcclusionQueryNV(UInt32 id)
		{
			glBeginOcclusionQueryNV(id);
		}

		public static unsafe void EndOcclusionQueryNV()
		{
			glEndOcclusionQueryNV();
		}

		public static unsafe void GetOcclusionQueryivNV(UInt32 id, GLEnum pname, [OutAttribute] Int32[] parameters)
		{
			fixed (Int32* optr848 = parameters) { glGetOcclusionQueryivNV(id, (uint)pname, optr848); } 
		}

		public static unsafe void GetOcclusionQueryuivNV(UInt32 id, GLEnum pname, [OutAttribute] UInt32[] parameters)
		{
			fixed (UInt32* optr849 = parameters) { glGetOcclusionQueryuivNV(id, (uint)pname, optr849); } 
		}

		public static unsafe void PointParameteriNV(GLEnum pname, Int32 param)
		{
			glPointParameteriNV((uint)pname, param);
		}

		public static unsafe void PointParameterivNV(GLEnum pname, Int32[] parameters)
		{
			fixed (Int32* ptr850 = &parameters[0]) { glPointParameterivNV((uint)pname, new IntPtr(ptr850)); } 
		}

		public static unsafe void ActiveStencilFaceEXT(GLEnum face)
		{
			glActiveStencilFaceEXT((uint)face);
		}

		public static unsafe void ElementPointerAPPLE(GLEnum type, IntPtr pointer)
		{
			glElementPointerAPPLE((uint)type, pointer);
		}

		public static unsafe void DrawElementArrayAPPLE(BeginMode mode, Int32 first, Int32 count)
		{
			glDrawElementArrayAPPLE((uint)mode, first, count);
		}

		public static unsafe void DrawRangeElementArrayAPPLE(BeginMode mode, UInt32 start, UInt32 end, Int32 first, Int32 count)
		{
			glDrawRangeElementArrayAPPLE((uint)mode, start, end, first, count);
		}

		public static unsafe void MultiDrawElementArrayAPPLE(BeginMode mode, Int32[] first, Int32[] count, Int32 primcount)
		{
			fixed (Int32* ptr852 = &count[0]) { fixed (Int32* ptr851 = &first[0]) { glMultiDrawElementArrayAPPLE((uint)mode, new IntPtr(ptr851), new IntPtr(ptr852), primcount); }  } 
		}

		public static unsafe void MultiDrawRangeElementArrayAPPLE(BeginMode mode, UInt32 start, UInt32 end, Int32[] first, Int32[] count, Int32 primcount)
		{
			fixed (Int32* ptr854 = &count[0]) { fixed (Int32* ptr853 = &first[0]) { glMultiDrawRangeElementArrayAPPLE((uint)mode, start, end, new IntPtr(ptr853), new IntPtr(ptr854), primcount); }  } 
		}

		public static unsafe void GenFencesAPPLE(Int32 n, [OutAttribute] UInt32[] fences)
		{
			fixed (UInt32* optr855 = fences) { glGenFencesAPPLE(n, optr855); } 
		}

		public static unsafe void DeleteFencesAPPLE(Int32 n, UInt32[] fences)
		{
			fixed (UInt32* ptr856 = &fences[0]) { glDeleteFencesAPPLE(n, new IntPtr(ptr856)); } 
		}

		public static unsafe void SetFenceAPPLE(UInt32 fence)
		{
			glSetFenceAPPLE(fence);
		}

		public static unsafe bool IsFenceAPPLE(UInt32 fence)
		{
			return (glIsFenceAPPLE(fence) == 1);
		}

		public static unsafe bool TestFenceAPPLE(UInt32 fence)
		{
			return (glTestFenceAPPLE(fence) == 1);
		}

		public static unsafe void FinishFenceAPPLE(UInt32 fence)
		{
			glFinishFenceAPPLE(fence);
		}

		public static unsafe bool TestObjectAPPLE(GLEnum obj, UInt32 name)
		{
			return (glTestObjectAPPLE((uint)obj, name) == 1);
		}

		public static unsafe void FinishObjectAPPLE(GLEnum obj, Int32 name)
		{
			glFinishObjectAPPLE((uint)obj, name);
		}

		public static unsafe void BindVertexArrayAPPLE(UInt32 array)
		{
			glBindVertexArrayAPPLE(array);
		}

		public static unsafe void DeleteVertexArraysAPPLE(Int32 n, UInt32[] arrays)
		{
			fixed (UInt32* ptr857 = &arrays[0]) { glDeleteVertexArraysAPPLE(n, new IntPtr(ptr857)); } 
		}

		public static unsafe void GenVertexArraysAPPLE(Int32 n, [OutAttribute] UInt32[] arrays)
		{
			fixed (UInt32* optr858 = arrays) { glGenVertexArraysAPPLE(n, optr858); } 
		}

		public static unsafe bool IsVertexArrayAPPLE(UInt32 array)
		{
			return (glIsVertexArrayAPPLE(array) == 1);
		}

		public static unsafe void VertexArrayRangeAPPLE(Int32 length, [OutAttribute] IntPtr pointer)
		{
			glVertexArrayRangeAPPLE(length, pointer);
		}

		public static unsafe void FlushVertexArrayRangeAPPLE(Int32 length, [OutAttribute] IntPtr pointer)
		{
			glFlushVertexArrayRangeAPPLE(length, pointer);
		}

		public static unsafe void VertexArrayParameteriAPPLE(GLEnum pname, Int32 param)
		{
			glVertexArrayParameteriAPPLE((uint)pname, param);
		}

		public static unsafe void DrawBuffersATI(Int32 n, GLEnum[] bufs)
		{
			fixed (GLEnum* ptr859 = &bufs[0]) { glDrawBuffersATI(n, new IntPtr(ptr859)); } 
		}

		public static unsafe void ProgramNamedParameter4fNV(UInt32 id, Int32 len, byte[] name, float x, float y, float z, float w)
		{
			fixed (byte* ptr860 = &name[0]) { glProgramNamedParameter4fNV(id, len, new IntPtr(ptr860), x, y, z, w); } 
		}

		public static unsafe void ProgramNamedParameter4dNV(UInt32 id, Int32 len, byte[] name, double x, double y, double z, double w)
		{
			fixed (byte* ptr861 = &name[0]) { glProgramNamedParameter4dNV(id, len, new IntPtr(ptr861), x, y, z, w); } 
		}

		public static unsafe void ProgramNamedParameter4fvNV(UInt32 id, Int32 len, byte[] name, float[] v)
		{
			fixed (float* ptr863 = &v[0]) { fixed (byte* ptr862 = &name[0]) { glProgramNamedParameter4fvNV(id, len, new IntPtr(ptr862), new IntPtr(ptr863)); }  } 
		}

		public static unsafe void ProgramNamedParameter4dvNV(UInt32 id, Int32 len, byte[] name, double[] v)
		{
			fixed (double* ptr865 = &v[0]) { fixed (byte* ptr864 = &name[0]) { glProgramNamedParameter4dvNV(id, len, new IntPtr(ptr864), new IntPtr(ptr865)); }  } 
		}

		public static unsafe void GetProgramNamedParameterfvNV(UInt32 id, Int32 len, byte[] name, [OutAttribute] float[] parameters)
		{
			fixed (float* optr867 = parameters) { fixed (byte* ptr866 = &name[0]) { glGetProgramNamedParameterfvNV(id, len, new IntPtr(ptr866), optr867); }  } 
		}

		public static unsafe void GetProgramNamedParameterdvNV(UInt32 id, Int32 len, byte[] name, [OutAttribute] double[] parameters)
		{
			fixed (double* optr869 = parameters) { fixed (byte* ptr868 = &name[0]) { glGetProgramNamedParameterdvNV(id, len, new IntPtr(ptr868), optr869); }  } 
		}

		public static unsafe void PixelDataRangeNV(GLEnum target, Int32 length, [OutAttribute] IntPtr pointer)
		{
			glPixelDataRangeNV((uint)target, length, pointer);
		}

		public static unsafe void FlushPixelDataRangeNV(GLEnum target)
		{
			glFlushPixelDataRangeNV((uint)target);
		}

		public static unsafe void PrimitiveRestartNV()
		{
			glPrimitiveRestartNV();
		}

		public static unsafe void PrimitiveRestartIndexNV(UInt32 index)
		{
			glPrimitiveRestartIndexNV(index);
		}

		public static unsafe IntPtr MapObjectBufferATI(UInt32 buffer)
		{
			return glMapObjectBufferATI(buffer);
		}

		public static unsafe void UnmapObjectBufferATI(UInt32 buffer)
		{
			glUnmapObjectBufferATI(buffer);
		}

		public static unsafe void StencilOpSeparateATI(GLEnum face, StencilOp sfail, StencilOp dpfail, StencilOp dppass)
		{
			glStencilOpSeparateATI((uint)face, (uint)sfail, (uint)dpfail, (uint)dppass);
		}

		public static unsafe void StencilFuncSeparateATI(StencilFunction frontfunc, StencilFunction backfunc, Int32 reference, UInt32 mask)
		{
			glStencilFuncSeparateATI((uint)frontfunc, (uint)backfunc, reference, mask);
		}

		public static unsafe void VertexAttribArrayObjectATI(UInt32 index, Int32 size, GLEnum type, bool normalized, Int32 stride, UInt32 buffer, UInt32 offset)
		{
			glVertexAttribArrayObjectATI(index, size, (uint)type, normalized ? ((byte)1) : ((byte)0), stride, buffer, offset);
		}

		public static unsafe void GetVertexAttribArrayObjectfvATI(UInt32 index, GLEnum pname, [OutAttribute] float[] parameters)
		{
			fixed (float* optr870 = parameters) { glGetVertexAttribArrayObjectfvATI(index, (uint)pname, optr870); } 
		}

		public static unsafe void GetVertexAttribArrayObjectivATI(UInt32 index, GLEnum pname, [OutAttribute] Int32[] parameters)
		{
			fixed (Int32* optr871 = parameters) { glGetVertexAttribArrayObjectivATI(index, (uint)pname, optr871); } 
		}

		public static unsafe void DepthBoundsEXT(double zmin, double zmax)
		{
			glDepthBoundsEXT(zmin, zmax);
		}

		public static unsafe void BlendEquationSeparateEXT(BlendEquationModeEXT modeRGB, BlendEquationModeEXT modeAlpha)
		{
			glBlendEquationSeparateEXT((uint)modeRGB, (uint)modeAlpha);
		}

		public static unsafe bool IsRenderbufferEXT(UInt32 renderbuffer)
		{
			return (glIsRenderbufferEXT(renderbuffer) == 1);
		}

		public static unsafe void BindRenderbufferEXT(GLEnum target, UInt32 renderbuffer)
		{
			glBindRenderbufferEXT((uint)target, renderbuffer);
		}

		public static unsafe void DeleteRenderbuffersEXT(Int32 n, UInt32[] renderbuffers)
		{
			fixed (UInt32* ptr872 = &renderbuffers[0]) { glDeleteRenderbuffersEXT(n, new IntPtr(ptr872)); } 
		}

		public static unsafe void GenRenderbuffersEXT(Int32 n, [OutAttribute] UInt32[] renderbuffers)
		{
			fixed (UInt32* optr873 = renderbuffers) { glGenRenderbuffersEXT(n, optr873); } 
		}

		public static unsafe void RenderbufferStorageEXT(GLEnum target, GLEnum internalformat, Int32 width, Int32 height)
		{
			glRenderbufferStorageEXT((uint)target, (uint)internalformat, width, height);
		}

		public static unsafe void GetRenderbufferParameterivEXT(GLEnum target, GLEnum pname, [OutAttribute] Int32[] parameters)
		{
			fixed (Int32* optr874 = parameters) { glGetRenderbufferParameterivEXT((uint)target, (uint)pname, optr874); } 
		}

		public static unsafe bool IsFramebufferEXT(UInt32 framebuffer)
		{
			return (glIsFramebufferEXT(framebuffer) == 1);
		}

		public static unsafe void BindFramebufferEXT(GLEnum target, UInt32 framebuffer)
		{
			glBindFramebufferEXT((uint)target, framebuffer);
		}

		public static unsafe void DeleteFramebuffersEXT(Int32 n, UInt32[] framebuffers)
		{
			fixed (UInt32* ptr875 = &framebuffers[0]) { glDeleteFramebuffersEXT(n, new IntPtr(ptr875)); } 
		}

		public static unsafe void GenFramebuffersEXT(Int32 n, [OutAttribute] UInt32[] framebuffers)
		{
			fixed (UInt32* optr876 = framebuffers) { glGenFramebuffersEXT(n, optr876); } 
		}

		public static unsafe GLEnum CheckFramebufferStatusEXT(GLEnum target)
		{
			return (GLEnum) glCheckFramebufferStatusEXT((uint)target);
		}

		public static unsafe void FramebufferTexture1DEXT(GLEnum target, GLEnum attachment, GLEnum textarget, UInt32 texture, Int32 level)
		{
			glFramebufferTexture1DEXT((uint)target, (uint)attachment, (uint)textarget, texture, level);
		}

		public static unsafe void FramebufferTexture2DEXT(GLEnum target, GLEnum attachment, GLEnum textarget, UInt32 texture, Int32 level)
		{
			glFramebufferTexture2DEXT((uint)target, (uint)attachment, (uint)textarget, texture, level);
		}

		public static unsafe void FramebufferTexture3DEXT(GLEnum target, GLEnum attachment, GLEnum textarget, UInt32 texture, Int32 level, Int32 zoffset)
		{
			glFramebufferTexture3DEXT((uint)target, (uint)attachment, (uint)textarget, texture, level, zoffset);
		}

		public static unsafe void FramebufferRenderbufferEXT(GLEnum target, GLEnum attachment, GLEnum renderbuffertarget, UInt32 renderbuffer)
		{
			glFramebufferRenderbufferEXT((uint)target, (uint)attachment, (uint)renderbuffertarget, renderbuffer);
		}

		public static unsafe void GetFramebufferAttachmentParameterivEXT(GLEnum target, GLEnum attachment, GLEnum pname, [OutAttribute] Int32[] parameters)
		{
			fixed (Int32* optr877 = parameters) { glGetFramebufferAttachmentParameterivEXT((uint)target, (uint)attachment, (uint)pname, optr877); } 
		}

		public static unsafe void GenerateMipmapEXT(GLEnum target)
		{
			glGenerateMipmapEXT((uint)target);
		}

		public static unsafe void StringMarkerGREMEDY(Int32 len, IntPtr str)
		{
			glStringMarkerGREMEDY(len, str);
		}

		public static unsafe void StencilClearTagEXT(Int32 stencilTagBits, UInt32 stencilClearTag)
		{
			glStencilClearTagEXT(stencilTagBits, stencilClearTag);
		}

		public static unsafe void BlitFramebufferEXT(Int32 srcX0, Int32 srcY0, Int32 srcX1, Int32 srcY1, Int32 dstX0, Int32 dstY0, Int32 dstX1, Int32 dstY1, UInt32 mask, GLEnum filter)
		{
			glBlitFramebufferEXT(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, (uint)filter);
		}

		public static unsafe void RenderbufferStorageMultisampleEXT(GLEnum target, Int32 samples, GLEnum internalformat, Int32 width, Int32 height)
		{
			glRenderbufferStorageMultisampleEXT((uint)target, samples, (uint)internalformat, width, height);
		}

		public static unsafe void GetQueryObjecti64vEXT(UInt32 id, GLEnum pname, [OutAttribute] Int64[] parameters)
		{
			fixed (Int64* optr878 = parameters) { glGetQueryObjecti64vEXT(id, (uint)pname, optr878); } 
		}

		public static unsafe void GetQueryObjectui64vEXT(UInt32 id, GLEnum pname, [OutAttribute] UInt64[] parameters)
		{
			fixed (UInt64* optr879 = parameters) { glGetQueryObjectui64vEXT(id, (uint)pname, optr879); } 
		}

		public static unsafe void ProgramEnvParameters4fvEXT(GLEnum target, UInt32 index, Int32 count, float[] parameters)
		{
			fixed (float* ptr880 = &parameters[0]) { glProgramEnvParameters4fvEXT((uint)target, index, count, new IntPtr(ptr880)); } 
		}

		public static unsafe void ProgramLocalParameters4fvEXT(GLEnum target, UInt32 index, Int32 count, float[] parameters)
		{
			fixed (float* ptr881 = &parameters[0]) { glProgramLocalParameters4fvEXT((uint)target, index, count, new IntPtr(ptr881)); } 
		}

		public static unsafe void BufferParameteriAPPLE(GLEnum target, GLEnum pname, Int32 param)
		{
			glBufferParameteriAPPLE((uint)target, (uint)pname, param);
		}

		public static unsafe void FlushMappedBufferRangeAPPLE(GLEnum target, IntPtr offset, IntPtr size)
		{
			glFlushMappedBufferRangeAPPLE((uint)target, offset, size);
		}

		public static unsafe void ProgramLocalParameterI4iNV(GLEnum target, UInt32 index, Int32 x, Int32 y, Int32 z, Int32 w)
		{
			glProgramLocalParameterI4iNV((uint)target, index, x, y, z, w);
		}

		public static unsafe void ProgramLocalParameterI4ivNV(GLEnum target, UInt32 index, Int32[] parameters)
		{
			fixed (Int32* ptr882 = &parameters[0]) { glProgramLocalParameterI4ivNV((uint)target, index, new IntPtr(ptr882)); } 
		}

		public static unsafe void ProgramLocalParametersI4ivNV(GLEnum target, UInt32 index, Int32 count, Int32[] parameters)
		{
			fixed (Int32* ptr883 = &parameters[0]) { glProgramLocalParametersI4ivNV((uint)target, index, count, new IntPtr(ptr883)); } 
		}

		public static unsafe void ProgramLocalParameterI4uiNV(GLEnum target, UInt32 index, UInt32 x, UInt32 y, UInt32 z, UInt32 w)
		{
			glProgramLocalParameterI4uiNV((uint)target, index, x, y, z, w);
		}

		public static unsafe void ProgramLocalParameterI4uivNV(GLEnum target, UInt32 index, UInt32[] parameters)
		{
			fixed (UInt32* ptr884 = &parameters[0]) { glProgramLocalParameterI4uivNV((uint)target, index, new IntPtr(ptr884)); } 
		}

		public static unsafe void ProgramLocalParametersI4uivNV(GLEnum target, UInt32 index, Int32 count, UInt32[] parameters)
		{
			fixed (UInt32* ptr885 = &parameters[0]) { glProgramLocalParametersI4uivNV((uint)target, index, count, new IntPtr(ptr885)); } 
		}

		public static unsafe void ProgramEnvParameterI4iNV(GLEnum target, UInt32 index, Int32 x, Int32 y, Int32 z, Int32 w)
		{
			glProgramEnvParameterI4iNV((uint)target, index, x, y, z, w);
		}

		public static unsafe void ProgramEnvParameterI4ivNV(GLEnum target, UInt32 index, Int32[] parameters)
		{
			fixed (Int32* ptr886 = &parameters[0]) { glProgramEnvParameterI4ivNV((uint)target, index, new IntPtr(ptr886)); } 
		}

		public static unsafe void ProgramEnvParametersI4ivNV(GLEnum target, UInt32 index, Int32 count, Int32[] parameters)
		{
			fixed (Int32* ptr887 = &parameters[0]) { glProgramEnvParametersI4ivNV((uint)target, index, count, new IntPtr(ptr887)); } 
		}

		public static unsafe void ProgramEnvParameterI4uiNV(GLEnum target, UInt32 index, UInt32 x, UInt32 y, UInt32 z, UInt32 w)
		{
			glProgramEnvParameterI4uiNV((uint)target, index, x, y, z, w);
		}

		public static unsafe void ProgramEnvParameterI4uivNV(GLEnum target, UInt32 index, UInt32[] parameters)
		{
			fixed (UInt32* ptr888 = &parameters[0]) { glProgramEnvParameterI4uivNV((uint)target, index, new IntPtr(ptr888)); } 
		}

		public static unsafe void ProgramEnvParametersI4uivNV(GLEnum target, UInt32 index, Int32 count, UInt32[] parameters)
		{
			fixed (UInt32* ptr889 = &parameters[0]) { glProgramEnvParametersI4uivNV((uint)target, index, count, new IntPtr(ptr889)); } 
		}

		public static unsafe void GetProgramLocalParameterIivNV(GLEnum target, UInt32 index, [OutAttribute] Int32[] parameters)
		{
			fixed (Int32* optr890 = parameters) { glGetProgramLocalParameterIivNV((uint)target, index, optr890); } 
		}

		public static unsafe void GetProgramLocalParameterIuivNV(GLEnum target, UInt32 index, [OutAttribute] UInt32[] parameters)
		{
			fixed (UInt32* optr891 = parameters) { glGetProgramLocalParameterIuivNV((uint)target, index, optr891); } 
		}

		public static unsafe void GetProgramEnvParameterIivNV(GLEnum target, UInt32 index, [OutAttribute] Int32[] parameters)
		{
			fixed (Int32* optr892 = parameters) { glGetProgramEnvParameterIivNV((uint)target, index, optr892); } 
		}

		public static unsafe void GetProgramEnvParameterIuivNV(GLEnum target, UInt32 index, [OutAttribute] UInt32[] parameters)
		{
			fixed (UInt32* optr893 = parameters) { glGetProgramEnvParameterIuivNV((uint)target, index, optr893); } 
		}

		public static unsafe void ProgramVertexLimitNV(GLEnum target, Int32 limit)
		{
			glProgramVertexLimitNV((uint)target, limit);
		}

		public static unsafe void FramebufferTextureEXT(GLEnum target, GLEnum attachment, UInt32 texture, Int32 level)
		{
			glFramebufferTextureEXT((uint)target, (uint)attachment, texture, level);
		}

		public static unsafe void FramebufferTextureLayerEXT(GLEnum target, GLEnum attachment, UInt32 texture, Int32 level, Int32 layer)
		{
			glFramebufferTextureLayerEXT((uint)target, (uint)attachment, texture, level, layer);
		}

		public static unsafe void FramebufferTextureFaceEXT(GLEnum target, GLEnum attachment, UInt32 texture, Int32 level, TextureTarget face)
		{
			glFramebufferTextureFaceEXT((uint)target, (uint)attachment, texture, level, (uint)face);
		}

		public static unsafe void ProgramParameteriEXT(UInt32 program, GLEnum pname, Int32 val)
		{
			glProgramParameteriEXT(program, (uint)pname, val);
		}

		public static unsafe void VertexAttribI1iEXT(UInt32 index, Int32 x)
		{
			glVertexAttribI1iEXT(index, x);
		}

		public static unsafe void VertexAttribI2iEXT(UInt32 index, Int32 x, Int32 y)
		{
			glVertexAttribI2iEXT(index, x, y);
		}

		public static unsafe void VertexAttribI3iEXT(UInt32 index, Int32 x, Int32 y, Int32 z)
		{
			glVertexAttribI3iEXT(index, x, y, z);
		}

		public static unsafe void VertexAttribI4iEXT(UInt32 index, Int32 x, Int32 y, Int32 z, Int32 w)
		{
			glVertexAttribI4iEXT(index, x, y, z, w);
		}

		public static unsafe void VertexAttribI1uiEXT(UInt32 index, UInt32 x)
		{
			glVertexAttribI1uiEXT(index, x);
		}

		public static unsafe void VertexAttribI2uiEXT(UInt32 index, UInt32 x, UInt32 y)
		{
			glVertexAttribI2uiEXT(index, x, y);
		}

		public static unsafe void VertexAttribI3uiEXT(UInt32 index, UInt32 x, UInt32 y, UInt32 z)
		{
			glVertexAttribI3uiEXT(index, x, y, z);
		}

		public static unsafe void VertexAttribI4uiEXT(UInt32 index, UInt32 x, UInt32 y, UInt32 z, UInt32 w)
		{
			glVertexAttribI4uiEXT(index, x, y, z, w);
		}

		public static unsafe void VertexAttribI1ivEXT(UInt32 index, Int32[] v)
		{
			fixed (Int32* ptr894 = &v[0]) { glVertexAttribI1ivEXT(index, new IntPtr(ptr894)); } 
		}

		public static unsafe void VertexAttribI2ivEXT(UInt32 index, Int32[] v)
		{
			fixed (Int32* ptr895 = &v[0]) { glVertexAttribI2ivEXT(index, new IntPtr(ptr895)); } 
		}

		public static unsafe void VertexAttribI3ivEXT(UInt32 index, Int32[] v)
		{
			fixed (Int32* ptr896 = &v[0]) { glVertexAttribI3ivEXT(index, new IntPtr(ptr896)); } 
		}

		public static unsafe void VertexAttribI4ivEXT(UInt32 index, Int32[] v)
		{
			fixed (Int32* ptr897 = &v[0]) { glVertexAttribI4ivEXT(index, new IntPtr(ptr897)); } 
		}

		public static unsafe void VertexAttribI1uivEXT(UInt32 index, UInt32[] v)
		{
			fixed (UInt32* ptr898 = &v[0]) { glVertexAttribI1uivEXT(index, new IntPtr(ptr898)); } 
		}

		public static unsafe void VertexAttribI2uivEXT(UInt32 index, UInt32[] v)
		{
			fixed (UInt32* ptr899 = &v[0]) { glVertexAttribI2uivEXT(index, new IntPtr(ptr899)); } 
		}

		public static unsafe void VertexAttribI3uivEXT(UInt32 index, UInt32[] v)
		{
			fixed (UInt32* ptr900 = &v[0]) { glVertexAttribI3uivEXT(index, new IntPtr(ptr900)); } 
		}

		public static unsafe void VertexAttribI4uivEXT(UInt32 index, UInt32[] v)
		{
			fixed (UInt32* ptr901 = &v[0]) { glVertexAttribI4uivEXT(index, new IntPtr(ptr901)); } 
		}

		public static unsafe void VertexAttribI4bvEXT(UInt32 index, SByte[] v)
		{
			fixed (SByte* ptr902 = &v[0]) { glVertexAttribI4bvEXT(index, new IntPtr(ptr902)); } 
		}

		public static unsafe void VertexAttribI4svEXT(UInt32 index, Int16[] v)
		{
			fixed (Int16* ptr903 = &v[0]) { glVertexAttribI4svEXT(index, new IntPtr(ptr903)); } 
		}

		public static unsafe void VertexAttribI4ubvEXT(UInt32 index, byte[] v)
		{
			fixed (byte* ptr904 = &v[0]) { glVertexAttribI4ubvEXT(index, new IntPtr(ptr904)); } 
		}

		public static unsafe void VertexAttribI4usvEXT(UInt32 index, UInt16[] v)
		{
			fixed (UInt16* ptr905 = &v[0]) { glVertexAttribI4usvEXT(index, new IntPtr(ptr905)); } 
		}

		public static unsafe void VertexAttribIPointerEXT(UInt32 index, Int32 size, GLEnum type, Int32 stride, IntPtr pointer)
		{
			glVertexAttribIPointerEXT(index, size, (uint)type, stride, pointer);
		}

		public static unsafe void GetVertexAttribIivEXT(UInt32 index, GLEnum pname, [OutAttribute] Int32[] parameters)
		{
			fixed (Int32* optr906 = parameters) { glGetVertexAttribIivEXT(index, (uint)pname, optr906); } 
		}

		public static unsafe void GetVertexAttribIuivEXT(UInt32 index, GLEnum pname, [OutAttribute] UInt32[] parameters)
		{
			fixed (UInt32* optr907 = parameters) { glGetVertexAttribIuivEXT(index, (uint)pname, optr907); } 
		}

		public static unsafe void GetUniformuivEXT(UInt32 program, Int32 location, [OutAttribute] UInt32[] parameters)
		{
			fixed (UInt32* optr908 = parameters) { glGetUniformuivEXT(program, location, optr908); } 
		}

		public static unsafe void BindFragDataLocationEXT(UInt32 program, UInt32 color, byte[] name)
		{
			fixed (byte* ptr909 = &name[0]) { glBindFragDataLocationEXT(program, color, new IntPtr(ptr909)); } 
		}

		public static unsafe Int32 GetFragDataLocationEXT(UInt32 program, byte[] name)
		{
			fixed (byte* ptr910 = &name[0]) { return glGetFragDataLocationEXT(program, new IntPtr(ptr910)); } 
		}

		public static unsafe void Uniform1uiEXT(Int32 location, UInt32 v0)
		{
			glUniform1uiEXT(location, v0);
		}

		public static unsafe void Uniform2uiEXT(Int32 location, UInt32 v0, UInt32 v1)
		{
			glUniform2uiEXT(location, v0, v1);
		}

		public static unsafe void Uniform3uiEXT(Int32 location, UInt32 v0, UInt32 v1, UInt32 v2)
		{
			glUniform3uiEXT(location, v0, v1, v2);
		}

		public static unsafe void Uniform4uiEXT(Int32 location, UInt32 v0, UInt32 v1, UInt32 v2, UInt32 v3)
		{
			glUniform4uiEXT(location, v0, v1, v2, v3);
		}

		public static unsafe void Uniform1uivEXT(Int32 location, Int32 count, UInt32[] val)
		{
			fixed (UInt32* ptr911 = &val[0]) { glUniform1uivEXT(location, count, new IntPtr(ptr911)); } 
		}

		public static unsafe void Uniform2uivEXT(Int32 location, Int32 count, UInt32[] val)
		{
			fixed (UInt32* ptr912 = &val[0]) { glUniform2uivEXT(location, count, new IntPtr(ptr912)); } 
		}

		public static unsafe void Uniform3uivEXT(Int32 location, Int32 count, UInt32[] val)
		{
			fixed (UInt32* ptr913 = &val[0]) { glUniform3uivEXT(location, count, new IntPtr(ptr913)); } 
		}

		public static unsafe void Uniform4uivEXT(Int32 location, Int32 count, UInt32[] val)
		{
			fixed (UInt32* ptr914 = &val[0]) { glUniform4uivEXT(location, count, new IntPtr(ptr914)); } 
		}

		public static unsafe void DrawArraysInstancedEXT(BeginMode mode, Int32 start, Int32 count, Int32 primcount)
		{
			glDrawArraysInstancedEXT((uint)mode, start, count, primcount);
		}

		public static unsafe void DrawElementsInstancedEXT(BeginMode mode, Int32 count, GLEnum type, IntPtr indices, Int32 primcount)
		{
			glDrawElementsInstancedEXT((uint)mode, count, (uint)type, indices, primcount);
		}

		public static unsafe void TexBufferEXT(TextureTarget target, GLEnum internalformat, UInt32 buffer)
		{
			glTexBufferEXT((uint)target, (uint)internalformat, buffer);
		}

		public static unsafe void DepthRangedNV(double zNear, double zFar)
		{
			glDepthRangedNV(zNear, zFar);
		}

		public static unsafe void ClearDepthdNV(double depth)
		{
			glClearDepthdNV(depth);
		}

		public static unsafe void DepthBoundsdNV(double zmin, double zmax)
		{
			glDepthBoundsdNV(zmin, zmax);
		}

		public static unsafe void RenderbufferStorageMultisampleCoverageNV(GLEnum target, Int32 coverageSamples, Int32 colorSamples, PixelInternalFormat internalformat, Int32 width, Int32 height)
		{
			glRenderbufferStorageMultisampleCoverageNV((uint)target, coverageSamples, colorSamples, (uint)internalformat, width, height);
		}

		public static unsafe void ProgramBufferParametersfvNV(GLEnum target, UInt32 buffer, UInt32 index, Int32 count, float[] parameters)
		{
			fixed (float* ptr915 = &parameters[0]) { glProgramBufferParametersfvNV((uint)target, buffer, index, count, new IntPtr(ptr915)); } 
		}

		public static unsafe void ProgramBufferParametersIivNV(GLEnum target, UInt32 buffer, UInt32 index, Int32 count, Int32[] parameters)
		{
			fixed (Int32* ptr916 = &parameters[0]) { glProgramBufferParametersIivNV((uint)target, buffer, index, count, new IntPtr(ptr916)); } 
		}

		public static unsafe void ProgramBufferParametersIuivNV(GLEnum target, UInt32 buffer, UInt32 index, Int32 count, UInt32[] parameters)
		{
			fixed (UInt32* ptr917 = &parameters[0]) { glProgramBufferParametersIuivNV((uint)target, buffer, index, count, new IntPtr(ptr917)); } 
		}

		public static unsafe void ColorMaskIndexedEXT(UInt32 index, bool r, bool g, bool b, bool a)
		{
			glColorMaskIndexedEXT(index, r ? ((byte)1) : ((byte)0), g ? ((byte)1) : ((byte)0), b ? ((byte)1) : ((byte)0), a ? ((byte)1) : ((byte)0));
		}

		public static unsafe void GetBooleanIndexedvEXT(GLEnum target, UInt32 index, [OutAttribute] bool[] data)
		{
			byte[] btr918 = new byte[1];
			fixed (byte* optr918 = btr918) { glGetBooleanIndexedvEXT((uint)target, index, optr918); }
			data = new bool[btr918.Length];
			for (int i918 = 0; i918< data.Length; i918++)
				data[i918] = (btr918[i918] == 1);
			 
		}

		public static unsafe void GetIntegerIndexedvEXT(GLEnum target, UInt32 index, [OutAttribute] Int32[] data)
		{
			fixed (Int32* optr919 = data) { glGetIntegerIndexedvEXT((uint)target, index, optr919); } 
		}

		public static unsafe void EnableIndexedEXT(GLEnum target, UInt32 index)
		{
			glEnableIndexedEXT((uint)target, index);
		}

		public static unsafe void DisableIndexedEXT(GLEnum target, UInt32 index)
		{
			glDisableIndexedEXT((uint)target, index);
		}

		public static unsafe bool IsEnabledIndexedEXT(GLEnum target, UInt32 index)
		{
			return (glIsEnabledIndexedEXT((uint)target, index) == 1);
		}

		public static unsafe void BeginTransformFeedbackNV(GLEnum primitiveMode)
		{
			glBeginTransformFeedbackNV((uint)primitiveMode);
		}

		public static unsafe void EndTransformFeedbackNV()
		{
			glEndTransformFeedbackNV();
		}

		public static unsafe void TransformFeedbackAttribsNV(UInt32 count, Int32[] attribs, GLEnum bufferMode)
		{
			fixed (Int32* ptr920 = &attribs[0]) { glTransformFeedbackAttribsNV(count, new IntPtr(ptr920), (uint)bufferMode); } 
		}

		public static unsafe void BindBufferRangeNV(GLEnum target, UInt32 index, UInt32 buffer, IntPtr offset, IntPtr size)
		{
			glBindBufferRangeNV((uint)target, index, buffer, offset, size);
		}

		public static unsafe void BindBufferOffsetNV(GLEnum target, UInt32 index, UInt32 buffer, IntPtr offset)
		{
			glBindBufferOffsetNV((uint)target, index, buffer, offset);
		}

		public static unsafe void BindBufferBaseNV(GLEnum target, UInt32 index, UInt32 buffer)
		{
			glBindBufferBaseNV((uint)target, index, buffer);
		}

		public static unsafe void TransformFeedbackVaryingsNV(UInt32 program, Int32 count, IntPtr[] varyings, GLEnum bufferMode)
		{
			fixed (IntPtr* ptr921 = &varyings[0]) { glTransformFeedbackVaryingsNV(program, count, new IntPtr(ptr921), (uint)bufferMode); } 
		}

		public static unsafe void ActiveVaryingNV(UInt32 program, byte[] name)
		{
			fixed (byte* ptr922 = &name[0]) { glActiveVaryingNV(program, new IntPtr(ptr922)); } 
		}

		public static unsafe Int32 GetVaryingLocationNV(UInt32 program, byte[] name)
		{
			fixed (byte* ptr923 = &name[0]) { return glGetVaryingLocationNV(program, new IntPtr(ptr923)); } 
		}

		public static unsafe void GetActiveVaryingNV(UInt32 program, UInt32 index, Int32 bufSize, [OutAttribute] Int32[] length, [OutAttribute] Int32[] size, [OutAttribute] GLEnum[] type, [OutAttribute] byte[] name)
		{
			fixed (byte* optr927 = name) { uint[] unt926 = new uint[type.Length];
			fixed (uint* ptr926 = unt926) { fixed (Int32* optr925 = size) { fixed (Int32* optr924 = length) { glGetActiveVaryingNV(program, index, bufSize, optr924, optr925, ptr926, optr927); }  }  } 
			for (int i = 0; i < unt926.Length; i++)
				type[i] = (GLEnum)unt926[i];
			 } 
		}

		public static unsafe void GetTransformFeedbackVaryingNV(UInt32 program, UInt32 index, [OutAttribute] Int32[] location)
		{
			fixed (Int32* optr928 = location) { glGetTransformFeedbackVaryingNV(program, index, optr928); } 
		}

		public static unsafe void UniformBufferEXT(UInt32 program, Int32 location, UInt32 buffer)
		{
			glUniformBufferEXT(program, location, buffer);
		}

		public static unsafe Int32 GetUniformBufferSizeEXT(UInt32 program, Int32 location)
		{
			return glGetUniformBufferSizeEXT(program, location);
		}

		public static unsafe IntPtr GetUniformOffsetEXT(UInt32 program, Int32 location)
		{
			return glGetUniformOffsetEXT(program, location);
		}

		public static unsafe void TexParameterIivEXT(TextureTarget target, TextureParameterName pname, Int32[] parameters)
		{
			fixed (Int32* ptr929 = &parameters[0]) { glTexParameterIivEXT((uint)target, (uint)pname, new IntPtr(ptr929)); } 
		}

		public static unsafe void TexParameterIuivEXT(TextureTarget target, TextureParameterName pname, UInt32[] parameters)
		{
			fixed (UInt32* ptr930 = &parameters[0]) { glTexParameterIuivEXT((uint)target, (uint)pname, new IntPtr(ptr930)); } 
		}

		public static unsafe void GetTexParameterIivEXT(TextureTarget target, GetTextureParameter pname, [OutAttribute] Int32[] parameters)
		{
			fixed (Int32* optr931 = parameters) { glGetTexParameterIivEXT((uint)target, (uint)pname, optr931); } 
		}

		public static unsafe void GetTexParameterIuivEXT(TextureTarget target, GetTextureParameter pname, [OutAttribute] UInt32[] parameters)
		{
			fixed (UInt32* optr932 = parameters) { glGetTexParameterIuivEXT((uint)target, (uint)pname, optr932); } 
		}

		public static unsafe void ClearColorIiEXT(Int32 red, Int32 green, Int32 blue, Int32 alpha)
		{
			glClearColorIiEXT(red, green, blue, alpha);
		}

		public static unsafe void ClearColorIuiEXT(UInt32 red, UInt32 green, UInt32 blue, UInt32 alpha)
		{
			glClearColorIuiEXT(red, green, blue, alpha);
		}

		public static unsafe void FrameTerminatorGREMEDY()
		{
			glFrameTerminatorGREMEDY();
		}

		public static unsafe void BeginConditionalRenderNV(UInt32 id, GLEnum mode)
		{
			glBeginConditionalRenderNV(id, (uint)mode);
		}

		public static unsafe void EndConditionalRenderNV()
		{
			glEndConditionalRenderNV();
		}

		public static unsafe void PresentFrameKeyedNV(UInt32 video_slot, UInt64 minPresentTime, UInt32 beginPresentTimeId, UInt32 presentDurationId, GLEnum type, GLEnum target0, UInt32 fill0, UInt32 key0, GLEnum target1, UInt32 fill1, UInt32 key1)
		{
			glPresentFrameKeyedNV(video_slot, minPresentTime, beginPresentTimeId, presentDurationId, (uint)type, (uint)target0, fill0, key0, (uint)target1, fill1, key1);
		}

		public static unsafe void PresentFrameDualFillNV(UInt32 video_slot, UInt64 minPresentTime, UInt32 beginPresentTimeId, UInt32 presentDurationId, GLEnum type, GLEnum target0, UInt32 fill0, GLEnum target1, UInt32 fill1, GLEnum target2, UInt32 fill2, GLEnum target3, UInt32 fill3)
		{
			glPresentFrameDualFillNV(video_slot, minPresentTime, beginPresentTimeId, presentDurationId, (uint)type, (uint)target0, fill0, (uint)target1, fill1, (uint)target2, fill2, (uint)target3, fill3);
		}

		public static unsafe void GetVideoivNV(UInt32 video_slot, GLEnum pname, [OutAttribute] Int32[] parameters)
		{
			fixed (Int32* optr933 = parameters) { glGetVideoivNV(video_slot, (uint)pname, optr933); } 
		}

		public static unsafe void GetVideouivNV(UInt32 video_slot, GLEnum pname, [OutAttribute] UInt32[] parameters)
		{
			fixed (UInt32* optr934 = parameters) { glGetVideouivNV(video_slot, (uint)pname, optr934); } 
		}

		public static unsafe void GetVideoi64vNV(UInt32 video_slot, GLEnum pname, [OutAttribute] Int64[] parameters)
		{
			fixed (Int64* optr935 = parameters) { glGetVideoi64vNV(video_slot, (uint)pname, optr935); } 
		}

		public static unsafe void GetVideoui64vNV(UInt32 video_slot, GLEnum pname, [OutAttribute] UInt64[] parameters)
		{
			fixed (UInt64* optr936 = parameters) { glGetVideoui64vNV(video_slot, (uint)pname, optr936); } 
		}

		public static unsafe void BeginTransformFeedbackEXT(GLEnum primitiveMode)
		{
			glBeginTransformFeedbackEXT((uint)primitiveMode);
		}

		public static unsafe void EndTransformFeedbackEXT()
		{
			glEndTransformFeedbackEXT();
		}

		public static unsafe void BindBufferRangeEXT(GLEnum target, UInt32 index, UInt32 buffer, IntPtr offset, IntPtr size)
		{
			glBindBufferRangeEXT((uint)target, index, buffer, offset, size);
		}

		public static unsafe void BindBufferOffsetEXT(GLEnum target, UInt32 index, UInt32 buffer, IntPtr offset)
		{
			glBindBufferOffsetEXT((uint)target, index, buffer, offset);
		}

		public static unsafe void BindBufferBaseEXT(GLEnum target, UInt32 index, UInt32 buffer)
		{
			glBindBufferBaseEXT((uint)target, index, buffer);
		}

		public static unsafe void TransformFeedbackVaryingsEXT(UInt32 program, Int32 count, IntPtr[] varyings, GLEnum bufferMode)
		{
			fixed (IntPtr* ptr937 = &varyings[0]) { glTransformFeedbackVaryingsEXT(program, count, new IntPtr(ptr937), (uint)bufferMode); } 
		}

		public static unsafe void GetTransformFeedbackVaryingEXT(UInt32 program, UInt32 index, Int32 bufSize, [OutAttribute] Int32[] length, [OutAttribute] Int32[] size, [OutAttribute] GLEnum[] type, [OutAttribute] byte[] name)
		{
			fixed (byte* optr941 = name) { uint[] unt940 = new uint[type.Length];
			fixed (uint* ptr940 = unt940) { fixed (Int32* optr939 = size) { fixed (Int32* optr938 = length) { glGetTransformFeedbackVaryingEXT(program, index, bufSize, optr938, optr939, ptr940, optr941); }  }  } 
			for (int i = 0; i < unt940.Length; i++)
				type[i] = (GLEnum)unt940[i];
			 } 
		}

		public static unsafe void ClientAttribDefaultEXT(UInt32 mask)
		{
			glClientAttribDefaultEXT(mask);
		}

		public static unsafe void PushClientAttribDefaultEXT(UInt32 mask)
		{
			glPushClientAttribDefaultEXT(mask);
		}

		public static unsafe void MatrixLoadfEXT(MatrixMode mode, float[] m)
		{
			fixed (float* ptr942 = &m[0]) { glMatrixLoadfEXT((uint)mode, new IntPtr(ptr942)); } 
		}

		public static unsafe void MatrixLoaddEXT(MatrixMode mode, double[] m)
		{
			fixed (double* ptr943 = &m[0]) { glMatrixLoaddEXT((uint)mode, new IntPtr(ptr943)); } 
		}

		public static unsafe void MatrixMultfEXT(MatrixMode mode, float[] m)
		{
			fixed (float* ptr944 = &m[0]) { glMatrixMultfEXT((uint)mode, new IntPtr(ptr944)); } 
		}

		public static unsafe void MatrixMultdEXT(MatrixMode mode, double[] m)
		{
			fixed (double* ptr945 = &m[0]) { glMatrixMultdEXT((uint)mode, new IntPtr(ptr945)); } 
		}

		public static unsafe void MatrixLoadIdentityEXT(MatrixMode mode)
		{
			glMatrixLoadIdentityEXT((uint)mode);
		}

		public static unsafe void MatrixRotatefEXT(MatrixMode mode, float angle, float x, float y, float z)
		{
			glMatrixRotatefEXT((uint)mode, angle, x, y, z);
		}

		public static unsafe void MatrixRotatedEXT(MatrixMode mode, double angle, double x, double y, double z)
		{
			glMatrixRotatedEXT((uint)mode, angle, x, y, z);
		}

		public static unsafe void MatrixScalefEXT(MatrixMode mode, float x, float y, float z)
		{
			glMatrixScalefEXT((uint)mode, x, y, z);
		}

		public static unsafe void MatrixScaledEXT(MatrixMode mode, double x, double y, double z)
		{
			glMatrixScaledEXT((uint)mode, x, y, z);
		}

		public static unsafe void MatrixTranslatefEXT(MatrixMode mode, float x, float y, float z)
		{
			glMatrixTranslatefEXT((uint)mode, x, y, z);
		}

		public static unsafe void MatrixTranslatedEXT(MatrixMode mode, double x, double y, double z)
		{
			glMatrixTranslatedEXT((uint)mode, x, y, z);
		}

		public static unsafe void MatrixFrustumEXT(MatrixMode mode, double left, double right, double bottom, double top, double zNear, double zFar)
		{
			glMatrixFrustumEXT((uint)mode, left, right, bottom, top, zNear, zFar);
		}

		public static unsafe void MatrixOrthoEXT(MatrixMode mode, double left, double right, double bottom, double top, double zNear, double zFar)
		{
			glMatrixOrthoEXT((uint)mode, left, right, bottom, top, zNear, zFar);
		}

		public static unsafe void MatrixPopEXT(MatrixMode mode)
		{
			glMatrixPopEXT((uint)mode);
		}

		public static unsafe void MatrixPushEXT(MatrixMode mode)
		{
			glMatrixPushEXT((uint)mode);
		}

		public static unsafe void MatrixLoadTransposefEXT(MatrixMode mode, float[] m)
		{
			fixed (float* ptr946 = &m[0]) { glMatrixLoadTransposefEXT((uint)mode, new IntPtr(ptr946)); } 
		}

		public static unsafe void MatrixLoadTransposedEXT(MatrixMode mode, double[] m)
		{
			fixed (double* ptr947 = &m[0]) { glMatrixLoadTransposedEXT((uint)mode, new IntPtr(ptr947)); } 
		}

		public static unsafe void MatrixMultTransposefEXT(MatrixMode mode, float[] m)
		{
			fixed (float* ptr948 = &m[0]) { glMatrixMultTransposefEXT((uint)mode, new IntPtr(ptr948)); } 
		}

		public static unsafe void MatrixMultTransposedEXT(MatrixMode mode, double[] m)
		{
			fixed (double* ptr949 = &m[0]) { glMatrixMultTransposedEXT((uint)mode, new IntPtr(ptr949)); } 
		}

		public static unsafe void TextureParameterfEXT(UInt32 texture, TextureTarget target, TextureParameterName pname, float param)
		{
			glTextureParameterfEXT(texture, (uint)target, (uint)pname, param);
		}

		public static unsafe void TextureParameterfvEXT(UInt32 texture, TextureTarget target, TextureParameterName pname, float[] parameters)
		{
			fixed (float* ptr950 = &parameters[0]) { glTextureParameterfvEXT(texture, (uint)target, (uint)pname, new IntPtr(ptr950)); } 
		}

		public static unsafe void TextureParameteriEXT(UInt32 texture, TextureTarget target, TextureParameterName pname, Int32 param)
		{
			glTextureParameteriEXT(texture, (uint)target, (uint)pname, param);
		}

		public static unsafe void TextureParameterivEXT(UInt32 texture, TextureTarget target, TextureParameterName pname, Int32[] parameters)
		{
			fixed (Int32* ptr951 = &parameters[0]) { glTextureParameterivEXT(texture, (uint)target, (uint)pname, new IntPtr(ptr951)); } 
		}

		public static unsafe void TextureImage1DEXT(UInt32 texture, TextureTarget target, Int32 level, GLEnum internalformat, Int32 width, Int32 border, PixelFormat format, PixelType type, IntPtr pixels)
		{
			glTextureImage1DEXT(texture, (uint)target, level, (uint)internalformat, width, border, (uint)format, (uint)type, pixels);
		}

		public static unsafe void TextureImage2DEXT(UInt32 texture, TextureTarget target, Int32 level, GLEnum internalformat, Int32 width, Int32 height, Int32 border, PixelFormat format, PixelType type, IntPtr pixels)
		{
			glTextureImage2DEXT(texture, (uint)target, level, (uint)internalformat, width, height, border, (uint)format, (uint)type, pixels);
		}

		public static unsafe void TextureSubImage1DEXT(UInt32 texture, TextureTarget target, Int32 level, Int32 xoffset, Int32 width, PixelFormat format, PixelType type, IntPtr pixels)
		{
			glTextureSubImage1DEXT(texture, (uint)target, level, xoffset, width, (uint)format, (uint)type, pixels);
		}

		public static unsafe void TextureSubImage2DEXT(UInt32 texture, TextureTarget target, Int32 level, Int32 xoffset, Int32 yoffset, Int32 width, Int32 height, PixelFormat format, PixelType type, IntPtr pixels)
		{
			glTextureSubImage2DEXT(texture, (uint)target, level, xoffset, yoffset, width, height, (uint)format, (uint)type, pixels);
		}

		public static unsafe void CopyTextureImage1DEXT(UInt32 texture, TextureTarget target, Int32 level, GLEnum internalformat, Int32 x, Int32 y, Int32 width, Int32 border)
		{
			glCopyTextureImage1DEXT(texture, (uint)target, level, (uint)internalformat, x, y, width, border);
		}

		public static unsafe void CopyTextureImage2DEXT(UInt32 texture, TextureTarget target, Int32 level, GLEnum internalformat, Int32 x, Int32 y, Int32 width, Int32 height, Int32 border)
		{
			glCopyTextureImage2DEXT(texture, (uint)target, level, (uint)internalformat, x, y, width, height, border);
		}

		public static unsafe void CopyTextureSubImage1DEXT(UInt32 texture, TextureTarget target, Int32 level, Int32 xoffset, Int32 x, Int32 y, Int32 width)
		{
			glCopyTextureSubImage1DEXT(texture, (uint)target, level, xoffset, x, y, width);
		}

		public static unsafe void CopyTextureSubImage2DEXT(UInt32 texture, TextureTarget target, Int32 level, Int32 xoffset, Int32 yoffset, Int32 x, Int32 y, Int32 width, Int32 height)
		{
			glCopyTextureSubImage2DEXT(texture, (uint)target, level, xoffset, yoffset, x, y, width, height);
		}

		public static unsafe void GetTextureImageEXT(UInt32 texture, TextureTarget target, Int32 level, PixelFormat format, PixelType type, [OutAttribute] IntPtr pixels)
		{
			glGetTextureImageEXT(texture, (uint)target, level, (uint)format, (uint)type, pixels);
		}

		public static unsafe void GetTextureParameterfvEXT(UInt32 texture, TextureTarget target, GetTextureParameter pname, [OutAttribute] float[] parameters)
		{
			fixed (float* optr952 = parameters) { glGetTextureParameterfvEXT(texture, (uint)target, (uint)pname, optr952); } 
		}

		public static unsafe void GetTextureParameterivEXT(UInt32 texture, TextureTarget target, GetTextureParameter pname, [OutAttribute] Int32[] parameters)
		{
			fixed (Int32* optr953 = parameters) { glGetTextureParameterivEXT(texture, (uint)target, (uint)pname, optr953); } 
		}

		public static unsafe void GetTextureLevelParameterfvEXT(UInt32 texture, TextureTarget target, Int32 level, GetTextureParameter pname, [OutAttribute] float[] parameters)
		{
			fixed (float* optr954 = parameters) { glGetTextureLevelParameterfvEXT(texture, (uint)target, level, (uint)pname, optr954); } 
		}

		public static unsafe void GetTextureLevelParameterivEXT(UInt32 texture, TextureTarget target, Int32 level, GetTextureParameter pname, [OutAttribute] Int32[] parameters)
		{
			fixed (Int32* optr955 = parameters) { glGetTextureLevelParameterivEXT(texture, (uint)target, level, (uint)pname, optr955); } 
		}

		public static unsafe void TextureImage3DEXT(UInt32 texture, TextureTarget target, Int32 level, GLEnum internalformat, Int32 width, Int32 height, Int32 depth, Int32 border, PixelFormat format, PixelType type, IntPtr pixels)
		{
			glTextureImage3DEXT(texture, (uint)target, level, (uint)internalformat, width, height, depth, border, (uint)format, (uint)type, pixels);
		}

		public static unsafe void TextureSubImage3DEXT(UInt32 texture, TextureTarget target, Int32 level, Int32 xoffset, Int32 yoffset, Int32 zoffset, Int32 width, Int32 height, Int32 depth, PixelFormat format, PixelType type, IntPtr pixels)
		{
			glTextureSubImage3DEXT(texture, (uint)target, level, xoffset, yoffset, zoffset, width, height, depth, (uint)format, (uint)type, pixels);
		}

		public static unsafe void CopyTextureSubImage3DEXT(UInt32 texture, TextureTarget target, Int32 level, Int32 xoffset, Int32 yoffset, Int32 zoffset, Int32 x, Int32 y, Int32 width, Int32 height)
		{
			glCopyTextureSubImage3DEXT(texture, (uint)target, level, xoffset, yoffset, zoffset, x, y, width, height);
		}

		public static unsafe void MultiTexParameterfEXT(GLEnum texunit, TextureTarget target, TextureParameterName pname, float param)
		{
			glMultiTexParameterfEXT((uint)texunit, (uint)target, (uint)pname, param);
		}

		public static unsafe void MultiTexParameterfvEXT(GLEnum texunit, TextureTarget target, TextureParameterName pname, float[] parameters)
		{
			fixed (float* ptr956 = &parameters[0]) { glMultiTexParameterfvEXT((uint)texunit, (uint)target, (uint)pname, new IntPtr(ptr956)); } 
		}

		public static unsafe void MultiTexParameteriEXT(GLEnum texunit, TextureTarget target, TextureParameterName pname, Int32 param)
		{
			glMultiTexParameteriEXT((uint)texunit, (uint)target, (uint)pname, param);
		}

		public static unsafe void MultiTexParameterivEXT(GLEnum texunit, TextureTarget target, TextureParameterName pname, Int32[] parameters)
		{
			fixed (Int32* ptr957 = &parameters[0]) { glMultiTexParameterivEXT((uint)texunit, (uint)target, (uint)pname, new IntPtr(ptr957)); } 
		}

		public static unsafe void MultiTexImage1DEXT(GLEnum texunit, TextureTarget target, Int32 level, GLEnum internalformat, Int32 width, Int32 border, PixelFormat format, PixelType type, IntPtr pixels)
		{
			glMultiTexImage1DEXT((uint)texunit, (uint)target, level, (uint)internalformat, width, border, (uint)format, (uint)type, pixels);
		}

		public static unsafe void MultiTexImage2DEXT(GLEnum texunit, TextureTarget target, Int32 level, GLEnum internalformat, Int32 width, Int32 height, Int32 border, PixelFormat format, PixelType type, IntPtr pixels)
		{
			glMultiTexImage2DEXT((uint)texunit, (uint)target, level, (uint)internalformat, width, height, border, (uint)format, (uint)type, pixels);
		}

		public static unsafe void MultiTexSubImage1DEXT(GLEnum texunit, TextureTarget target, Int32 level, Int32 xoffset, Int32 width, PixelFormat format, PixelType type, IntPtr pixels)
		{
			glMultiTexSubImage1DEXT((uint)texunit, (uint)target, level, xoffset, width, (uint)format, (uint)type, pixels);
		}

		public static unsafe void MultiTexSubImage2DEXT(GLEnum texunit, TextureTarget target, Int32 level, Int32 xoffset, Int32 yoffset, Int32 width, Int32 height, PixelFormat format, PixelType type, IntPtr pixels)
		{
			glMultiTexSubImage2DEXT((uint)texunit, (uint)target, level, xoffset, yoffset, width, height, (uint)format, (uint)type, pixels);
		}

		public static unsafe void CopyMultiTexImage1DEXT(GLEnum texunit, TextureTarget target, Int32 level, GLEnum internalformat, Int32 x, Int32 y, Int32 width, Int32 border)
		{
			glCopyMultiTexImage1DEXT((uint)texunit, (uint)target, level, (uint)internalformat, x, y, width, border);
		}

		public static unsafe void CopyMultiTexImage2DEXT(GLEnum texunit, TextureTarget target, Int32 level, GLEnum internalformat, Int32 x, Int32 y, Int32 width, Int32 height, Int32 border)
		{
			glCopyMultiTexImage2DEXT((uint)texunit, (uint)target, level, (uint)internalformat, x, y, width, height, border);
		}

		public static unsafe void CopyMultiTexSubImage1DEXT(GLEnum texunit, TextureTarget target, Int32 level, Int32 xoffset, Int32 x, Int32 y, Int32 width)
		{
			glCopyMultiTexSubImage1DEXT((uint)texunit, (uint)target, level, xoffset, x, y, width);
		}

		public static unsafe void CopyMultiTexSubImage2DEXT(GLEnum texunit, TextureTarget target, Int32 level, Int32 xoffset, Int32 yoffset, Int32 x, Int32 y, Int32 width, Int32 height)
		{
			glCopyMultiTexSubImage2DEXT((uint)texunit, (uint)target, level, xoffset, yoffset, x, y, width, height);
		}

		public static unsafe void GetMultiTexImageEXT(GLEnum texunit, TextureTarget target, Int32 level, PixelFormat format, PixelType type, [OutAttribute] IntPtr pixels)
		{
			glGetMultiTexImageEXT((uint)texunit, (uint)target, level, (uint)format, (uint)type, pixels);
		}

		public static unsafe void GetMultiTexParameterfvEXT(GLEnum texunit, TextureTarget target, GetTextureParameter pname, [OutAttribute] float[] parameters)
		{
			fixed (float* optr958 = parameters) { glGetMultiTexParameterfvEXT((uint)texunit, (uint)target, (uint)pname, optr958); } 
		}

		public static unsafe void GetMultiTexParameterivEXT(GLEnum texunit, TextureTarget target, GetTextureParameter pname, [OutAttribute] Int32[] parameters)
		{
			fixed (Int32* optr959 = parameters) { glGetMultiTexParameterivEXT((uint)texunit, (uint)target, (uint)pname, optr959); } 
		}

		public static unsafe void GetMultiTexLevelParameterfvEXT(GLEnum texunit, TextureTarget target, Int32 level, GetTextureParameter pname, [OutAttribute] float[] parameters)
		{
			fixed (float* optr960 = parameters) { glGetMultiTexLevelParameterfvEXT((uint)texunit, (uint)target, level, (uint)pname, optr960); } 
		}

		public static unsafe void GetMultiTexLevelParameterivEXT(GLEnum texunit, TextureTarget target, Int32 level, GetTextureParameter pname, [OutAttribute] Int32[] parameters)
		{
			fixed (Int32* optr961 = parameters) { glGetMultiTexLevelParameterivEXT((uint)texunit, (uint)target, level, (uint)pname, optr961); } 
		}

		public static unsafe void MultiTexImage3DEXT(GLEnum texunit, TextureTarget target, Int32 level, GLEnum internalformat, Int32 width, Int32 height, Int32 depth, Int32 border, PixelFormat format, PixelType type, IntPtr pixels)
		{
			glMultiTexImage3DEXT((uint)texunit, (uint)target, level, (uint)internalformat, width, height, depth, border, (uint)format, (uint)type, pixels);
		}

		public static unsafe void MultiTexSubImage3DEXT(GLEnum texunit, TextureTarget target, Int32 level, Int32 xoffset, Int32 yoffset, Int32 zoffset, Int32 width, Int32 height, Int32 depth, PixelFormat format, PixelType type, IntPtr pixels)
		{
			glMultiTexSubImage3DEXT((uint)texunit, (uint)target, level, xoffset, yoffset, zoffset, width, height, depth, (uint)format, (uint)type, pixels);
		}

		public static unsafe void CopyMultiTexSubImage3DEXT(GLEnum texunit, TextureTarget target, Int32 level, Int32 xoffset, Int32 yoffset, Int32 zoffset, Int32 x, Int32 y, Int32 width, Int32 height)
		{
			glCopyMultiTexSubImage3DEXT((uint)texunit, (uint)target, level, xoffset, yoffset, zoffset, x, y, width, height);
		}

		public static unsafe void BindMultiTextureEXT(GLEnum texunit, TextureTarget target, UInt32 texture)
		{
			glBindMultiTextureEXT((uint)texunit, (uint)target, texture);
		}

		public static unsafe void EnableClientStateIndexedEXT(EnableCap array, UInt32 index)
		{
			glEnableClientStateIndexedEXT((uint)array, index);
		}

		public static unsafe void DisableClientStateIndexedEXT(EnableCap array, UInt32 index)
		{
			glDisableClientStateIndexedEXT((uint)array, index);
		}

		public static unsafe void MultiTexCoordPointerEXT(GLEnum texunit, Int32 size, TexCoordPointerType type, Int32 stride, IntPtr pointer)
		{
			glMultiTexCoordPointerEXT((uint)texunit, size, (uint)type, stride, pointer);
		}

		public static unsafe void MultiTexEnvfEXT(GLEnum texunit, TextureEnvTarget target, TextureEnvParameter pname, float param)
		{
			glMultiTexEnvfEXT((uint)texunit, (uint)target, (uint)pname, param);
		}

		public static unsafe void MultiTexEnvfvEXT(GLEnum texunit, TextureEnvTarget target, TextureEnvParameter pname, float[] parameters)
		{
			fixed (float* ptr962 = &parameters[0]) { glMultiTexEnvfvEXT((uint)texunit, (uint)target, (uint)pname, new IntPtr(ptr962)); } 
		}

		public static unsafe void MultiTexEnviEXT(GLEnum texunit, TextureEnvTarget target, TextureEnvParameter pname, Int32 param)
		{
			glMultiTexEnviEXT((uint)texunit, (uint)target, (uint)pname, param);
		}

		public static unsafe void MultiTexEnvivEXT(GLEnum texunit, TextureEnvTarget target, TextureEnvParameter pname, Int32[] parameters)
		{
			fixed (Int32* ptr963 = &parameters[0]) { glMultiTexEnvivEXT((uint)texunit, (uint)target, (uint)pname, new IntPtr(ptr963)); } 
		}

		public static unsafe void MultiTexGendEXT(GLEnum texunit, TextureCoordName coord, TextureGenParameter pname, double param)
		{
			glMultiTexGendEXT((uint)texunit, (uint)coord, (uint)pname, param);
		}

		public static unsafe void MultiTexGendvEXT(GLEnum texunit, TextureCoordName coord, TextureGenParameter pname, double[] parameters)
		{
			fixed (double* ptr964 = &parameters[0]) { glMultiTexGendvEXT((uint)texunit, (uint)coord, (uint)pname, new IntPtr(ptr964)); } 
		}

		public static unsafe void MultiTexGenfEXT(GLEnum texunit, TextureCoordName coord, TextureGenParameter pname, float param)
		{
			glMultiTexGenfEXT((uint)texunit, (uint)coord, (uint)pname, param);
		}

		public static unsafe void MultiTexGenfvEXT(GLEnum texunit, TextureCoordName coord, TextureGenParameter pname, float[] parameters)
		{
			fixed (float* ptr965 = &parameters[0]) { glMultiTexGenfvEXT((uint)texunit, (uint)coord, (uint)pname, new IntPtr(ptr965)); } 
		}

		public static unsafe void MultiTexGeniEXT(GLEnum texunit, TextureCoordName coord, TextureGenParameter pname, Int32 param)
		{
			glMultiTexGeniEXT((uint)texunit, (uint)coord, (uint)pname, param);
		}

		public static unsafe void MultiTexGenivEXT(GLEnum texunit, TextureCoordName coord, TextureGenParameter pname, Int32[] parameters)
		{
			fixed (Int32* ptr966 = &parameters[0]) { glMultiTexGenivEXT((uint)texunit, (uint)coord, (uint)pname, new IntPtr(ptr966)); } 
		}

		public static unsafe void GetMultiTexEnvfvEXT(GLEnum texunit, TextureEnvTarget target, TextureEnvParameter pname, [OutAttribute] float[] parameters)
		{
			fixed (float* optr967 = parameters) { glGetMultiTexEnvfvEXT((uint)texunit, (uint)target, (uint)pname, optr967); } 
		}

		public static unsafe void GetMultiTexEnvivEXT(GLEnum texunit, TextureEnvTarget target, TextureEnvParameter pname, [OutAttribute] Int32[] parameters)
		{
			fixed (Int32* optr968 = parameters) { glGetMultiTexEnvivEXT((uint)texunit, (uint)target, (uint)pname, optr968); } 
		}

		public static unsafe void GetMultiTexGendvEXT(GLEnum texunit, TextureCoordName coord, TextureGenParameter pname, [OutAttribute] double[] parameters)
		{
			fixed (double* optr969 = parameters) { glGetMultiTexGendvEXT((uint)texunit, (uint)coord, (uint)pname, optr969); } 
		}

		public static unsafe void GetMultiTexGenfvEXT(GLEnum texunit, TextureCoordName coord, TextureGenParameter pname, [OutAttribute] float[] parameters)
		{
			fixed (float* optr970 = parameters) { glGetMultiTexGenfvEXT((uint)texunit, (uint)coord, (uint)pname, optr970); } 
		}

		public static unsafe void GetMultiTexGenivEXT(GLEnum texunit, TextureCoordName coord, TextureGenParameter pname, [OutAttribute] Int32[] parameters)
		{
			fixed (Int32* optr971 = parameters) { glGetMultiTexGenivEXT((uint)texunit, (uint)coord, (uint)pname, optr971); } 
		}

		public static unsafe void GetFloatIndexedvEXT(GLEnum target, UInt32 index, [OutAttribute] float[] data)
		{
			fixed (float* optr972 = data) { glGetFloatIndexedvEXT((uint)target, index, optr972); } 
		}

		public static unsafe void GetDoubleIndexedvEXT(GLEnum target, UInt32 index, [OutAttribute] double[] data)
		{
			fixed (double* optr973 = data) { glGetDoubleIndexedvEXT((uint)target, index, optr973); } 
		}

		public static unsafe void GetPointerIndexedvEXT(GLEnum target, UInt32 index, [OutAttribute] IntPtr[] data)
		{
			fixed (IntPtr* optr974 = data) { glGetPointerIndexedvEXT((uint)target, index, optr974); } 
		}

		public static unsafe void CompressedTextureImage3DEXT(UInt32 texture, TextureTarget target, Int32 level, GLEnum internalformat, Int32 width, Int32 height, Int32 depth, Int32 border, Int32 imageSize, IntPtr bits)
		{
			glCompressedTextureImage3DEXT(texture, (uint)target, level, (uint)internalformat, width, height, depth, border, imageSize, bits);
		}

		public static unsafe void CompressedTextureImage2DEXT(UInt32 texture, TextureTarget target, Int32 level, GLEnum internalformat, Int32 width, Int32 height, Int32 border, Int32 imageSize, IntPtr bits)
		{
			glCompressedTextureImage2DEXT(texture, (uint)target, level, (uint)internalformat, width, height, border, imageSize, bits);
		}

		public static unsafe void CompressedTextureImage1DEXT(UInt32 texture, TextureTarget target, Int32 level, GLEnum internalformat, Int32 width, Int32 border, Int32 imageSize, IntPtr bits)
		{
			glCompressedTextureImage1DEXT(texture, (uint)target, level, (uint)internalformat, width, border, imageSize, bits);
		}

		public static unsafe void CompressedTextureSubImage3DEXT(UInt32 texture, TextureTarget target, Int32 level, Int32 xoffset, Int32 yoffset, Int32 zoffset, Int32 width, Int32 height, Int32 depth, PixelFormat format, Int32 imageSize, IntPtr bits)
		{
			glCompressedTextureSubImage3DEXT(texture, (uint)target, level, xoffset, yoffset, zoffset, width, height, depth, (uint)format, imageSize, bits);
		}

		public static unsafe void CompressedTextureSubImage2DEXT(UInt32 texture, TextureTarget target, Int32 level, Int32 xoffset, Int32 yoffset, Int32 width, Int32 height, PixelFormat format, Int32 imageSize, IntPtr bits)
		{
			glCompressedTextureSubImage2DEXT(texture, (uint)target, level, xoffset, yoffset, width, height, (uint)format, imageSize, bits);
		}

		public static unsafe void CompressedTextureSubImage1DEXT(UInt32 texture, TextureTarget target, Int32 level, Int32 xoffset, Int32 width, PixelFormat format, Int32 imageSize, IntPtr bits)
		{
			glCompressedTextureSubImage1DEXT(texture, (uint)target, level, xoffset, width, (uint)format, imageSize, bits);
		}

		public static unsafe void GetCompressedTextureImageEXT(UInt32 texture, TextureTarget target, Int32 lod, [OutAttribute] IntPtr img)
		{
			glGetCompressedTextureImageEXT(texture, (uint)target, lod, img);
		}

		public static unsafe void CompressedMultiTexImage3DEXT(GLEnum texunit, TextureTarget target, Int32 level, GLEnum internalformat, Int32 width, Int32 height, Int32 depth, Int32 border, Int32 imageSize, IntPtr bits)
		{
			glCompressedMultiTexImage3DEXT((uint)texunit, (uint)target, level, (uint)internalformat, width, height, depth, border, imageSize, bits);
		}

		public static unsafe void CompressedMultiTexImage2DEXT(GLEnum texunit, TextureTarget target, Int32 level, GLEnum internalformat, Int32 width, Int32 height, Int32 border, Int32 imageSize, IntPtr bits)
		{
			glCompressedMultiTexImage2DEXT((uint)texunit, (uint)target, level, (uint)internalformat, width, height, border, imageSize, bits);
		}

		public static unsafe void CompressedMultiTexImage1DEXT(GLEnum texunit, TextureTarget target, Int32 level, GLEnum internalformat, Int32 width, Int32 border, Int32 imageSize, IntPtr bits)
		{
			glCompressedMultiTexImage1DEXT((uint)texunit, (uint)target, level, (uint)internalformat, width, border, imageSize, bits);
		}

		public static unsafe void CompressedMultiTexSubImage3DEXT(GLEnum texunit, TextureTarget target, Int32 level, Int32 xoffset, Int32 yoffset, Int32 zoffset, Int32 width, Int32 height, Int32 depth, PixelFormat format, Int32 imageSize, IntPtr bits)
		{
			glCompressedMultiTexSubImage3DEXT((uint)texunit, (uint)target, level, xoffset, yoffset, zoffset, width, height, depth, (uint)format, imageSize, bits);
		}

		public static unsafe void CompressedMultiTexSubImage2DEXT(GLEnum texunit, TextureTarget target, Int32 level, Int32 xoffset, Int32 yoffset, Int32 width, Int32 height, PixelFormat format, Int32 imageSize, IntPtr bits)
		{
			glCompressedMultiTexSubImage2DEXT((uint)texunit, (uint)target, level, xoffset, yoffset, width, height, (uint)format, imageSize, bits);
		}

		public static unsafe void CompressedMultiTexSubImage1DEXT(GLEnum texunit, TextureTarget target, Int32 level, Int32 xoffset, Int32 width, PixelFormat format, Int32 imageSize, IntPtr bits)
		{
			glCompressedMultiTexSubImage1DEXT((uint)texunit, (uint)target, level, xoffset, width, (uint)format, imageSize, bits);
		}

		public static unsafe void GetCompressedMultiTexImageEXT(GLEnum texunit, TextureTarget target, Int32 lod, [OutAttribute] IntPtr img)
		{
			glGetCompressedMultiTexImageEXT((uint)texunit, (uint)target, lod, img);
		}

		public static unsafe void NamedProgramStringEXT(UInt32 program, GLEnum target, GLEnum format, Int32 len, IntPtr str)
		{
			glNamedProgramStringEXT(program, (uint)target, (uint)format, len, str);
		}

		public static unsafe void NamedProgramLocalParameter4dEXT(UInt32 program, GLEnum target, UInt32 index, double x, double y, double z, double w)
		{
			glNamedProgramLocalParameter4dEXT(program, (uint)target, index, x, y, z, w);
		}

		public static unsafe void NamedProgramLocalParameter4dvEXT(UInt32 program, GLEnum target, UInt32 index, double[] parameters)
		{
			fixed (double* ptr975 = &parameters[0]) { glNamedProgramLocalParameter4dvEXT(program, (uint)target, index, new IntPtr(ptr975)); } 
		}

		public static unsafe void NamedProgramLocalParameter4fEXT(UInt32 program, GLEnum target, UInt32 index, float x, float y, float z, float w)
		{
			glNamedProgramLocalParameter4fEXT(program, (uint)target, index, x, y, z, w);
		}

		public static unsafe void NamedProgramLocalParameter4fvEXT(UInt32 program, GLEnum target, UInt32 index, float[] parameters)
		{
			fixed (float* ptr976 = &parameters[0]) { glNamedProgramLocalParameter4fvEXT(program, (uint)target, index, new IntPtr(ptr976)); } 
		}

		public static unsafe void GetNamedProgramLocalParameterdvEXT(UInt32 program, GLEnum target, UInt32 index, [OutAttribute] double[] parameters)
		{
			fixed (double* optr977 = parameters) { glGetNamedProgramLocalParameterdvEXT(program, (uint)target, index, optr977); } 
		}

		public static unsafe void GetNamedProgramLocalParameterfvEXT(UInt32 program, GLEnum target, UInt32 index, [OutAttribute] float[] parameters)
		{
			fixed (float* optr978 = parameters) { glGetNamedProgramLocalParameterfvEXT(program, (uint)target, index, optr978); } 
		}

		public static unsafe void GetNamedProgramivEXT(UInt32 program, GLEnum target, GLEnum pname, [OutAttribute] Int32[] parameters)
		{
			fixed (Int32* optr979 = parameters) { glGetNamedProgramivEXT(program, (uint)target, (uint)pname, optr979); } 
		}

		public static unsafe void GetNamedProgramStringEXT(UInt32 program, GLEnum target, GLEnum pname, [OutAttribute] IntPtr str)
		{
			glGetNamedProgramStringEXT(program, (uint)target, (uint)pname, str);
		}

		public static unsafe void NamedProgramLocalParameters4fvEXT(UInt32 program, GLEnum target, UInt32 index, Int32 count, float[] parameters)
		{
			fixed (float* ptr980 = &parameters[0]) { glNamedProgramLocalParameters4fvEXT(program, (uint)target, index, count, new IntPtr(ptr980)); } 
		}

		public static unsafe void NamedProgramLocalParameterI4iEXT(UInt32 program, GLEnum target, UInt32 index, Int32 x, Int32 y, Int32 z, Int32 w)
		{
			glNamedProgramLocalParameterI4iEXT(program, (uint)target, index, x, y, z, w);
		}

		public static unsafe void NamedProgramLocalParameterI4ivEXT(UInt32 program, GLEnum target, UInt32 index, Int32[] parameters)
		{
			fixed (Int32* ptr981 = &parameters[0]) { glNamedProgramLocalParameterI4ivEXT(program, (uint)target, index, new IntPtr(ptr981)); } 
		}

		public static unsafe void NamedProgramLocalParametersI4ivEXT(UInt32 program, GLEnum target, UInt32 index, Int32 count, Int32[] parameters)
		{
			fixed (Int32* ptr982 = &parameters[0]) { glNamedProgramLocalParametersI4ivEXT(program, (uint)target, index, count, new IntPtr(ptr982)); } 
		}

		public static unsafe void NamedProgramLocalParameterI4uiEXT(UInt32 program, GLEnum target, UInt32 index, UInt32 x, UInt32 y, UInt32 z, UInt32 w)
		{
			glNamedProgramLocalParameterI4uiEXT(program, (uint)target, index, x, y, z, w);
		}

		public static unsafe void NamedProgramLocalParameterI4uivEXT(UInt32 program, GLEnum target, UInt32 index, UInt32[] parameters)
		{
			fixed (UInt32* ptr983 = &parameters[0]) { glNamedProgramLocalParameterI4uivEXT(program, (uint)target, index, new IntPtr(ptr983)); } 
		}

		public static unsafe void NamedProgramLocalParametersI4uivEXT(UInt32 program, GLEnum target, UInt32 index, Int32 count, UInt32[] parameters)
		{
			fixed (UInt32* ptr984 = &parameters[0]) { glNamedProgramLocalParametersI4uivEXT(program, (uint)target, index, count, new IntPtr(ptr984)); } 
		}

		public static unsafe void GetNamedProgramLocalParameterIivEXT(UInt32 program, GLEnum target, UInt32 index, [OutAttribute] Int32[] parameters)
		{
			fixed (Int32* optr985 = parameters) { glGetNamedProgramLocalParameterIivEXT(program, (uint)target, index, optr985); } 
		}

		public static unsafe void GetNamedProgramLocalParameterIuivEXT(UInt32 program, GLEnum target, UInt32 index, [OutAttribute] UInt32[] parameters)
		{
			fixed (UInt32* optr986 = parameters) { glGetNamedProgramLocalParameterIuivEXT(program, (uint)target, index, optr986); } 
		}

		public static unsafe void TextureParameterIivEXT(UInt32 texture, TextureTarget target, TextureParameterName pname, Int32[] parameters)
		{
			fixed (Int32* ptr987 = &parameters[0]) { glTextureParameterIivEXT(texture, (uint)target, (uint)pname, new IntPtr(ptr987)); } 
		}

		public static unsafe void TextureParameterIuivEXT(UInt32 texture, TextureTarget target, TextureParameterName pname, UInt32[] parameters)
		{
			fixed (UInt32* ptr988 = &parameters[0]) { glTextureParameterIuivEXT(texture, (uint)target, (uint)pname, new IntPtr(ptr988)); } 
		}

		public static unsafe void GetTextureParameterIivEXT(UInt32 texture, TextureTarget target, GetTextureParameter pname, [OutAttribute] Int32[] parameters)
		{
			fixed (Int32* optr989 = parameters) { glGetTextureParameterIivEXT(texture, (uint)target, (uint)pname, optr989); } 
		}

		public static unsafe void GetTextureParameterIuivEXT(UInt32 texture, TextureTarget target, GetTextureParameter pname, [OutAttribute] UInt32[] parameters)
		{
			fixed (UInt32* optr990 = parameters) { glGetTextureParameterIuivEXT(texture, (uint)target, (uint)pname, optr990); } 
		}

		public static unsafe void MultiTexParameterIivEXT(GLEnum texunit, TextureTarget target, TextureParameterName pname, Int32[] parameters)
		{
			fixed (Int32* ptr991 = &parameters[0]) { glMultiTexParameterIivEXT((uint)texunit, (uint)target, (uint)pname, new IntPtr(ptr991)); } 
		}

		public static unsafe void MultiTexParameterIuivEXT(GLEnum texunit, TextureTarget target, TextureParameterName pname, UInt32[] parameters)
		{
			fixed (UInt32* ptr992 = &parameters[0]) { glMultiTexParameterIuivEXT((uint)texunit, (uint)target, (uint)pname, new IntPtr(ptr992)); } 
		}

		public static unsafe void GetMultiTexParameterIivEXT(GLEnum texunit, TextureTarget target, GetTextureParameter pname, [OutAttribute] Int32[] parameters)
		{
			fixed (Int32* optr993 = parameters) { glGetMultiTexParameterIivEXT((uint)texunit, (uint)target, (uint)pname, optr993); } 
		}

		public static unsafe void GetMultiTexParameterIuivEXT(GLEnum texunit, TextureTarget target, GetTextureParameter pname, [OutAttribute] UInt32[] parameters)
		{
			fixed (UInt32* optr994 = parameters) { glGetMultiTexParameterIuivEXT((uint)texunit, (uint)target, (uint)pname, optr994); } 
		}

		public static unsafe void ProgramUniform1fEXT(UInt32 program, Int32 location, float v0)
		{
			glProgramUniform1fEXT(program, location, v0);
		}

		public static unsafe void ProgramUniform2fEXT(UInt32 program, Int32 location, float v0, float v1)
		{
			glProgramUniform2fEXT(program, location, v0, v1);
		}

		public static unsafe void ProgramUniform3fEXT(UInt32 program, Int32 location, float v0, float v1, float v2)
		{
			glProgramUniform3fEXT(program, location, v0, v1, v2);
		}

		public static unsafe void ProgramUniform4fEXT(UInt32 program, Int32 location, float v0, float v1, float v2, float v3)
		{
			glProgramUniform4fEXT(program, location, v0, v1, v2, v3);
		}

		public static unsafe void ProgramUniform1iEXT(UInt32 program, Int32 location, Int32 v0)
		{
			glProgramUniform1iEXT(program, location, v0);
		}

		public static unsafe void ProgramUniform2iEXT(UInt32 program, Int32 location, Int32 v0, Int32 v1)
		{
			glProgramUniform2iEXT(program, location, v0, v1);
		}

		public static unsafe void ProgramUniform3iEXT(UInt32 program, Int32 location, Int32 v0, Int32 v1, Int32 v2)
		{
			glProgramUniform3iEXT(program, location, v0, v1, v2);
		}

		public static unsafe void ProgramUniform4iEXT(UInt32 program, Int32 location, Int32 v0, Int32 v1, Int32 v2, Int32 v3)
		{
			glProgramUniform4iEXT(program, location, v0, v1, v2, v3);
		}

		public static unsafe void ProgramUniform1fvEXT(UInt32 program, Int32 location, Int32 count, float[] val)
		{
			fixed (float* ptr995 = &val[0]) { glProgramUniform1fvEXT(program, location, count, new IntPtr(ptr995)); } 
		}

		public static unsafe void ProgramUniform2fvEXT(UInt32 program, Int32 location, Int32 count, float[] val)
		{
			fixed (float* ptr996 = &val[0]) { glProgramUniform2fvEXT(program, location, count, new IntPtr(ptr996)); } 
		}

		public static unsafe void ProgramUniform3fvEXT(UInt32 program, Int32 location, Int32 count, float[] val)
		{
			fixed (float* ptr997 = &val[0]) { glProgramUniform3fvEXT(program, location, count, new IntPtr(ptr997)); } 
		}

		public static unsafe void ProgramUniform4fvEXT(UInt32 program, Int32 location, Int32 count, float[] val)
		{
			fixed (float* ptr998 = &val[0]) { glProgramUniform4fvEXT(program, location, count, new IntPtr(ptr998)); } 
		}

		public static unsafe void ProgramUniform1ivEXT(UInt32 program, Int32 location, Int32 count, Int32[] val)
		{
			fixed (Int32* ptr999 = &val[0]) { glProgramUniform1ivEXT(program, location, count, new IntPtr(ptr999)); } 
		}

		public static unsafe void ProgramUniform2ivEXT(UInt32 program, Int32 location, Int32 count, Int32[] val)
		{
			fixed (Int32* ptr1000 = &val[0]) { glProgramUniform2ivEXT(program, location, count, new IntPtr(ptr1000)); } 
		}

		public static unsafe void ProgramUniform3ivEXT(UInt32 program, Int32 location, Int32 count, Int32[] val)
		{
			fixed (Int32* ptr1001 = &val[0]) { glProgramUniform3ivEXT(program, location, count, new IntPtr(ptr1001)); } 
		}

		public static unsafe void ProgramUniform4ivEXT(UInt32 program, Int32 location, Int32 count, Int32[] val)
		{
			fixed (Int32* ptr1002 = &val[0]) { glProgramUniform4ivEXT(program, location, count, new IntPtr(ptr1002)); } 
		}

		public static unsafe void ProgramUniformMatrix2fvEXT(UInt32 program, Int32 location, Int32 count, bool transpose, float[] val)
		{
			fixed (float* ptr1003 = &val[0]) { glProgramUniformMatrix2fvEXT(program, location, count, transpose ? ((byte)1) : ((byte)0), new IntPtr(ptr1003)); } 
		}

		public static unsafe void ProgramUniformMatrix3fvEXT(UInt32 program, Int32 location, Int32 count, bool transpose, float[] val)
		{
			fixed (float* ptr1004 = &val[0]) { glProgramUniformMatrix3fvEXT(program, location, count, transpose ? ((byte)1) : ((byte)0), new IntPtr(ptr1004)); } 
		}

		public static unsafe void ProgramUniformMatrix4fvEXT(UInt32 program, Int32 location, Int32 count, bool transpose, float[] val)
		{
			fixed (float* ptr1005 = &val[0]) { glProgramUniformMatrix4fvEXT(program, location, count, transpose ? ((byte)1) : ((byte)0), new IntPtr(ptr1005)); } 
		}

		public static unsafe void ProgramUniformMatrix2x3fvEXT(UInt32 program, Int32 location, Int32 count, bool transpose, float[] val)
		{
			fixed (float* ptr1006 = &val[0]) { glProgramUniformMatrix2x3fvEXT(program, location, count, transpose ? ((byte)1) : ((byte)0), new IntPtr(ptr1006)); } 
		}

		public static unsafe void ProgramUniformMatrix3x2fvEXT(UInt32 program, Int32 location, Int32 count, bool transpose, float[] val)
		{
			fixed (float* ptr1007 = &val[0]) { glProgramUniformMatrix3x2fvEXT(program, location, count, transpose ? ((byte)1) : ((byte)0), new IntPtr(ptr1007)); } 
		}

		public static unsafe void ProgramUniformMatrix2x4fvEXT(UInt32 program, Int32 location, Int32 count, bool transpose, float[] val)
		{
			fixed (float* ptr1008 = &val[0]) { glProgramUniformMatrix2x4fvEXT(program, location, count, transpose ? ((byte)1) : ((byte)0), new IntPtr(ptr1008)); } 
		}

		public static unsafe void ProgramUniformMatrix4x2fvEXT(UInt32 program, Int32 location, Int32 count, bool transpose, float[] val)
		{
			fixed (float* ptr1009 = &val[0]) { glProgramUniformMatrix4x2fvEXT(program, location, count, transpose ? ((byte)1) : ((byte)0), new IntPtr(ptr1009)); } 
		}

		public static unsafe void ProgramUniformMatrix3x4fvEXT(UInt32 program, Int32 location, Int32 count, bool transpose, float[] val)
		{
			fixed (float* ptr1010 = &val[0]) { glProgramUniformMatrix3x4fvEXT(program, location, count, transpose ? ((byte)1) : ((byte)0), new IntPtr(ptr1010)); } 
		}

		public static unsafe void ProgramUniformMatrix4x3fvEXT(UInt32 program, Int32 location, Int32 count, bool transpose, float[] val)
		{
			fixed (float* ptr1011 = &val[0]) { glProgramUniformMatrix4x3fvEXT(program, location, count, transpose ? ((byte)1) : ((byte)0), new IntPtr(ptr1011)); } 
		}

		public static unsafe void ProgramUniform1uiEXT(UInt32 program, Int32 location, UInt32 v0)
		{
			glProgramUniform1uiEXT(program, location, v0);
		}

		public static unsafe void ProgramUniform2uiEXT(UInt32 program, Int32 location, UInt32 v0, UInt32 v1)
		{
			glProgramUniform2uiEXT(program, location, v0, v1);
		}

		public static unsafe void ProgramUniform3uiEXT(UInt32 program, Int32 location, UInt32 v0, UInt32 v1, UInt32 v2)
		{
			glProgramUniform3uiEXT(program, location, v0, v1, v2);
		}

		public static unsafe void ProgramUniform4uiEXT(UInt32 program, Int32 location, UInt32 v0, UInt32 v1, UInt32 v2, UInt32 v3)
		{
			glProgramUniform4uiEXT(program, location, v0, v1, v2, v3);
		}

		public static unsafe void ProgramUniform1uivEXT(UInt32 program, Int32 location, Int32 count, UInt32[] val)
		{
			fixed (UInt32* ptr1012 = &val[0]) { glProgramUniform1uivEXT(program, location, count, new IntPtr(ptr1012)); } 
		}

		public static unsafe void ProgramUniform2uivEXT(UInt32 program, Int32 location, Int32 count, UInt32[] val)
		{
			fixed (UInt32* ptr1013 = &val[0]) { glProgramUniform2uivEXT(program, location, count, new IntPtr(ptr1013)); } 
		}

		public static unsafe void ProgramUniform3uivEXT(UInt32 program, Int32 location, Int32 count, UInt32[] val)
		{
			fixed (UInt32* ptr1014 = &val[0]) { glProgramUniform3uivEXT(program, location, count, new IntPtr(ptr1014)); } 
		}

		public static unsafe void ProgramUniform4uivEXT(UInt32 program, Int32 location, Int32 count, UInt32[] val)
		{
			fixed (UInt32* ptr1015 = &val[0]) { glProgramUniform4uivEXT(program, location, count, new IntPtr(ptr1015)); } 
		}

		public static unsafe void NamedBufferDataEXT(UInt32 buffer, IntPtr size, IntPtr data, GLEnum usage)
		{
			glNamedBufferDataEXT(buffer, size, data, (uint)usage);
		}

		public static unsafe void NamedBufferSubDataEXT(UInt32 buffer, IntPtr offset, IntPtr size, IntPtr data)
		{
			glNamedBufferSubDataEXT(buffer, offset, size, data);
		}

		public static unsafe IntPtr MapNamedBufferEXT(UInt32 buffer, GLEnum access)
		{
			return glMapNamedBufferEXT(buffer, (uint)access);
		}

		public static unsafe bool UnmapNamedBufferEXT(UInt32 buffer)
		{
			return (glUnmapNamedBufferEXT(buffer) == 1);
		}

		public static unsafe IntPtr MapNamedBufferRangeEXT(UInt32 buffer, IntPtr offset, IntPtr length, UInt32 access)
		{
			return glMapNamedBufferRangeEXT(buffer, offset, length, access);
		}

		public static unsafe void FlushMappedNamedBufferRangeEXT(UInt32 buffer, IntPtr offset, IntPtr length)
		{
			glFlushMappedNamedBufferRangeEXT(buffer, offset, length);
		}

		public static unsafe void NamedCopyBufferSubDataEXT(UInt32 readBuffer, UInt32 writeBuffer, IntPtr readOffset, IntPtr writeOffset, IntPtr size)
		{
			glNamedCopyBufferSubDataEXT(readBuffer, writeBuffer, readOffset, writeOffset, size);
		}

		public static unsafe void GetNamedBufferParameterivEXT(UInt32 buffer, GLEnum pname, [OutAttribute] Int32[] parameters)
		{
			fixed (Int32* optr1016 = parameters) { glGetNamedBufferParameterivEXT(buffer, (uint)pname, optr1016); } 
		}

		public static unsafe void GetNamedBufferPointervEXT(UInt32 buffer, GLEnum pname, [OutAttribute] IntPtr[] parameters)
		{
			fixed (IntPtr* optr1017 = parameters) { glGetNamedBufferPointervEXT(buffer, (uint)pname, optr1017); } 
		}

		public static unsafe void GetNamedBufferSubDataEXT(UInt32 buffer, IntPtr offset, IntPtr size, [OutAttribute] IntPtr data)
		{
			glGetNamedBufferSubDataEXT(buffer, offset, size, data);
		}

		public static unsafe void TextureBufferEXT(UInt32 texture, TextureTarget target, GLEnum internalformat, UInt32 buffer)
		{
			glTextureBufferEXT(texture, (uint)target, (uint)internalformat, buffer);
		}

		public static unsafe void MultiTexBufferEXT(GLEnum texunit, TextureTarget target, GLEnum internalformat, UInt32 buffer)
		{
			glMultiTexBufferEXT((uint)texunit, (uint)target, (uint)internalformat, buffer);
		}

		public static unsafe void NamedRenderbufferStorageEXT(UInt32 renderbuffer, PixelInternalFormat internalformat, Int32 width, Int32 height)
		{
			glNamedRenderbufferStorageEXT(renderbuffer, (uint)internalformat, width, height);
		}

		public static unsafe void GetNamedRenderbufferParameterivEXT(UInt32 renderbuffer, GLEnum pname, [OutAttribute] Int32[] parameters)
		{
			fixed (Int32* optr1018 = parameters) { glGetNamedRenderbufferParameterivEXT(renderbuffer, (uint)pname, optr1018); } 
		}

		public static unsafe GLEnum CheckNamedFramebufferStatusEXT(UInt32 framebuffer, GLEnum target)
		{
			return (GLEnum) glCheckNamedFramebufferStatusEXT(framebuffer, (uint)target);
		}

		public static unsafe void NamedFramebufferTexture1DEXT(UInt32 framebuffer, GLEnum attachment, TextureTarget textarget, UInt32 texture, Int32 level)
		{
			glNamedFramebufferTexture1DEXT(framebuffer, (uint)attachment, (uint)textarget, texture, level);
		}

		public static unsafe void NamedFramebufferTexture2DEXT(UInt32 framebuffer, GLEnum attachment, TextureTarget textarget, UInt32 texture, Int32 level)
		{
			glNamedFramebufferTexture2DEXT(framebuffer, (uint)attachment, (uint)textarget, texture, level);
		}

		public static unsafe void NamedFramebufferTexture3DEXT(UInt32 framebuffer, GLEnum attachment, TextureTarget textarget, UInt32 texture, Int32 level, Int32 zoffset)
		{
			glNamedFramebufferTexture3DEXT(framebuffer, (uint)attachment, (uint)textarget, texture, level, zoffset);
		}

		public static unsafe void NamedFramebufferRenderbufferEXT(UInt32 framebuffer, GLEnum attachment, GLEnum renderbuffertarget, UInt32 renderbuffer)
		{
			glNamedFramebufferRenderbufferEXT(framebuffer, (uint)attachment, (uint)renderbuffertarget, renderbuffer);
		}

		public static unsafe void GetNamedFramebufferAttachmentParameterivEXT(UInt32 framebuffer, GLEnum attachment, GLEnum pname, [OutAttribute] Int32[] parameters)
		{
			fixed (Int32* optr1019 = parameters) { glGetNamedFramebufferAttachmentParameterivEXT(framebuffer, (uint)attachment, (uint)pname, optr1019); } 
		}

		public static unsafe void GenerateTextureMipmapEXT(UInt32 texture, TextureTarget target)
		{
			glGenerateTextureMipmapEXT(texture, (uint)target);
		}

		public static unsafe void GenerateMultiTexMipmapEXT(GLEnum texunit, TextureTarget target)
		{
			glGenerateMultiTexMipmapEXT((uint)texunit, (uint)target);
		}

		public static unsafe void FramebufferDrawBufferEXT(UInt32 framebuffer, DrawBufferMode mode)
		{
			glFramebufferDrawBufferEXT(framebuffer, (uint)mode);
		}

		public static unsafe void FramebufferDrawBuffersEXT(UInt32 framebuffer, Int32 n, DrawBufferMode[] bufs)
		{
			fixed (DrawBufferMode* ptr1020 = &bufs[0]) { glFramebufferDrawBuffersEXT(framebuffer, n, new IntPtr(ptr1020)); } 
		}

		public static unsafe void FramebufferReadBufferEXT(UInt32 framebuffer, ReadBufferMode mode)
		{
			glFramebufferReadBufferEXT(framebuffer, (uint)mode);
		}

		public static unsafe void GetFramebufferParameterivEXT(UInt32 framebuffer, GLEnum pname, [OutAttribute] Int32[] parameters)
		{
			fixed (Int32* optr1021 = parameters) { glGetFramebufferParameterivEXT(framebuffer, (uint)pname, optr1021); } 
		}

		public static unsafe void NamedRenderbufferStorageMultisampleEXT(UInt32 renderbuffer, Int32 samples, PixelInternalFormat internalformat, Int32 width, Int32 height)
		{
			glNamedRenderbufferStorageMultisampleEXT(renderbuffer, samples, (uint)internalformat, width, height);
		}

		public static unsafe void NamedRenderbufferStorageMultisampleCoverageEXT(UInt32 renderbuffer, Int32 coverageSamples, Int32 colorSamples, PixelInternalFormat internalformat, Int32 width, Int32 height)
		{
			glNamedRenderbufferStorageMultisampleCoverageEXT(renderbuffer, coverageSamples, colorSamples, (uint)internalformat, width, height);
		}

		public static unsafe void NamedFramebufferTextureEXT(UInt32 framebuffer, GLEnum attachment, UInt32 texture, Int32 level)
		{
			glNamedFramebufferTextureEXT(framebuffer, (uint)attachment, texture, level);
		}

		public static unsafe void NamedFramebufferTextureLayerEXT(UInt32 framebuffer, GLEnum attachment, UInt32 texture, Int32 level, Int32 layer)
		{
			glNamedFramebufferTextureLayerEXT(framebuffer, (uint)attachment, texture, level, layer);
		}

		public static unsafe void NamedFramebufferTextureFaceEXT(UInt32 framebuffer, GLEnum attachment, UInt32 texture, Int32 level, TextureTarget face)
		{
			glNamedFramebufferTextureFaceEXT(framebuffer, (uint)attachment, texture, level, (uint)face);
		}

		public static unsafe void TextureRenderbufferEXT(UInt32 texture, TextureTarget target, UInt32 renderbuffer)
		{
			glTextureRenderbufferEXT(texture, (uint)target, renderbuffer);
		}

		public static unsafe void MultiTexRenderbufferEXT(GLEnum texunit, TextureTarget target, UInt32 renderbuffer)
		{
			glMultiTexRenderbufferEXT((uint)texunit, (uint)target, renderbuffer);
		}

		public static unsafe void GetMultisamplefvNV(GLEnum pname, UInt32 index, [OutAttribute] float[] val)
		{
			fixed (float* optr1022 = val) { glGetMultisamplefvNV((uint)pname, index, optr1022); } 
		}

		public static unsafe void SampleMaskIndexedNV(UInt32 index, UInt32 mask)
		{
			glSampleMaskIndexedNV(index, mask);
		}

		public static unsafe void TexRenderbufferNV(TextureTarget target, UInt32 renderbuffer)
		{
			glTexRenderbufferNV((uint)target, renderbuffer);
		}

		public static unsafe void BindTransformFeedbackNV(GLEnum target, UInt32 id)
		{
			glBindTransformFeedbackNV((uint)target, id);
		}

		public static unsafe void DeleteTransformFeedbacksNV(Int32 n, UInt32[] ids)
		{
			fixed (UInt32* ptr1023 = &ids[0]) { glDeleteTransformFeedbacksNV(n, new IntPtr(ptr1023)); } 
		}

		public static unsafe void GenTransformFeedbacksNV(Int32 n, [OutAttribute] UInt32[] ids)
		{
			fixed (UInt32* optr1024 = ids) { glGenTransformFeedbacksNV(n, optr1024); } 
		}

		public static unsafe bool IsTransformFeedbackNV(UInt32 id)
		{
			return (glIsTransformFeedbackNV(id) == 1);
		}

		public static unsafe void PauseTransformFeedbackNV()
		{
			glPauseTransformFeedbackNV();
		}

		public static unsafe void ResumeTransformFeedbackNV()
		{
			glResumeTransformFeedbackNV();
		}

		public static unsafe void DrawTransformFeedbackNV(GLEnum mode, UInt32 id)
		{
			glDrawTransformFeedbackNV((uint)mode, id);
		}

		public static unsafe void GetPerfMonitorGroupsAMD([OutAttribute] Int32[] numGroups, Int32 groupsSize, [OutAttribute] UInt32[] groups)
		{
			fixed (UInt32* optr1026 = groups) { fixed (Int32* optr1025 = numGroups) { glGetPerfMonitorGroupsAMD(optr1025, groupsSize, optr1026); }  } 
		}

		public static unsafe void GetPerfMonitorCountersAMD(UInt32 group, [OutAttribute] Int32[] numCounters, [OutAttribute] Int32[] maxActiveCounters, Int32 counterSize, [OutAttribute] UInt32[] counters)
		{
			fixed (UInt32* optr1029 = counters) { fixed (Int32* optr1028 = maxActiveCounters) { fixed (Int32* optr1027 = numCounters) { glGetPerfMonitorCountersAMD(group, optr1027, optr1028, counterSize, optr1029); }  }  } 
		}

		public static unsafe void GetPerfMonitorGroupStringAMD(UInt32 group, Int32 bufSize, [OutAttribute] Int32[] length, [OutAttribute] byte[] groupString)
		{
			fixed (byte* optr1031 = groupString) { fixed (Int32* optr1030 = length) { glGetPerfMonitorGroupStringAMD(group, bufSize, optr1030, optr1031); }  } 
		}

		public static unsafe void GetPerfMonitorCounterStringAMD(UInt32 group, UInt32 counter, Int32 bufSize, [OutAttribute] Int32[] length, [OutAttribute] byte[] counterString)
		{
			fixed (byte* optr1033 = counterString) { fixed (Int32* optr1032 = length) { glGetPerfMonitorCounterStringAMD(group, counter, bufSize, optr1032, optr1033); }  } 
		}

		public static unsafe void GetPerfMonitorCounterInfoAMD(UInt32 group, UInt32 counter, GLEnum pname, [OutAttribute] IntPtr data)
		{
			glGetPerfMonitorCounterInfoAMD(group, counter, (uint)pname, data);
		}

		public static unsafe void GenPerfMonitorsAMD(Int32 n, [OutAttribute] UInt32[] monitors)
		{
			fixed (UInt32* optr1034 = monitors) { glGenPerfMonitorsAMD(n, optr1034); } 
		}

		public static unsafe void DeletePerfMonitorsAMD(Int32 n, [OutAttribute] UInt32[] monitors)
		{
			fixed (UInt32* optr1035 = monitors) { glDeletePerfMonitorsAMD(n, optr1035); } 
		}

		public static unsafe void SelectPerfMonitorCountersAMD(UInt32 monitor, bool enable, UInt32 group, Int32 numCounters, [OutAttribute] UInt32[] counterList)
		{
			fixed (UInt32* optr1036 = counterList) { glSelectPerfMonitorCountersAMD(monitor, enable ? ((byte)1) : ((byte)0), group, numCounters, optr1036); } 
		}

		public static unsafe void BeginPerfMonitorAMD(UInt32 monitor)
		{
			glBeginPerfMonitorAMD(monitor);
		}

		public static unsafe void EndPerfMonitorAMD(UInt32 monitor)
		{
			glEndPerfMonitorAMD(monitor);
		}

		public static unsafe void GetPerfMonitorCounterDataAMD(UInt32 monitor, GLEnum pname, Int32 dataSize, [OutAttribute] UInt32[] data, [OutAttribute] Int32[] bytesWritten)
		{
			fixed (Int32* optr1038 = bytesWritten) { fixed (UInt32* optr1037 = data) { glGetPerfMonitorCounterDataAMD(monitor, (uint)pname, dataSize, optr1037, optr1038); }  } 
		}

		public static unsafe void TessellationFactorAMD(float factor)
		{
			glTessellationFactorAMD(factor);
		}

		public static unsafe void TessellationModeAMD(GLEnum mode)
		{
			glTessellationModeAMD((uint)mode);
		}

		public static unsafe void ProvokingVertexEXT(GLEnum mode)
		{
			glProvokingVertexEXT((uint)mode);
		}

		public static unsafe void BlendFuncIndexedAMD(UInt32 buf, GLEnum src, GLEnum dst)
		{
			glBlendFuncIndexedAMD(buf, (uint)src, (uint)dst);
		}

		public static unsafe void BlendFuncSeparateIndexedAMD(UInt32 buf, GLEnum srcRGB, GLEnum dstRGB, GLEnum srcAlpha, GLEnum dstAlpha)
		{
			glBlendFuncSeparateIndexedAMD(buf, (uint)srcRGB, (uint)dstRGB, (uint)srcAlpha, (uint)dstAlpha);
		}

		public static unsafe void BlendEquationIndexedAMD(UInt32 buf, GLEnum mode)
		{
			glBlendEquationIndexedAMD(buf, (uint)mode);
		}

		public static unsafe void BlendEquationSeparateIndexedAMD(UInt32 buf, GLEnum modeRGB, GLEnum modeAlpha)
		{
			glBlendEquationSeparateIndexedAMD(buf, (uint)modeRGB, (uint)modeAlpha);
		}

		public static unsafe void TextureRangeAPPLE(GLEnum target, Int32 length, IntPtr pointer)
		{
			glTextureRangeAPPLE((uint)target, length, pointer);
		}

		public static unsafe void GetTexParameterPointervAPPLE(GLEnum target, GLEnum pname, [OutAttribute] IntPtr[] parameters)
		{
			fixed (IntPtr* optr1039 = parameters) { glGetTexParameterPointervAPPLE((uint)target, (uint)pname, optr1039); } 
		}

		public static unsafe void EnableVertexAttribAPPLE(UInt32 index, GLEnum pname)
		{
			glEnableVertexAttribAPPLE(index, (uint)pname);
		}

		public static unsafe void DisableVertexAttribAPPLE(UInt32 index, GLEnum pname)
		{
			glDisableVertexAttribAPPLE(index, (uint)pname);
		}

		public static unsafe bool IsVertexAttribEnabledAPPLE(UInt32 index, GLEnum pname)
		{
			return (glIsVertexAttribEnabledAPPLE(index, (uint)pname) == 1);
		}

		public static unsafe void MapVertexAttrib1dAPPLE(UInt32 index, UInt32 size, double u1, double u2, Int32 stride, Int32 order, double[] points)
		{
			fixed (double* ptr1040 = &points[0]) { glMapVertexAttrib1dAPPLE(index, size, u1, u2, stride, order, new IntPtr(ptr1040)); } 
		}

		public static unsafe void MapVertexAttrib1fAPPLE(UInt32 index, UInt32 size, float u1, float u2, Int32 stride, Int32 order, float[] points)
		{
			fixed (float* ptr1041 = &points[0]) { glMapVertexAttrib1fAPPLE(index, size, u1, u2, stride, order, new IntPtr(ptr1041)); } 
		}

		public static unsafe void MapVertexAttrib2dAPPLE(UInt32 index, UInt32 size, double u1, double u2, Int32 ustride, Int32 uorder, double v1, double v2, Int32 vstride, Int32 vorder, double[] points)
		{
			fixed (double* ptr1042 = &points[0]) { glMapVertexAttrib2dAPPLE(index, size, u1, u2, ustride, uorder, v1, v2, vstride, vorder, new IntPtr(ptr1042)); } 
		}

		public static unsafe void MapVertexAttrib2fAPPLE(UInt32 index, UInt32 size, float u1, float u2, Int32 ustride, Int32 uorder, float v1, float v2, Int32 vstride, Int32 vorder, float[] points)
		{
			fixed (float* ptr1043 = &points[0]) { glMapVertexAttrib2fAPPLE(index, size, u1, u2, ustride, uorder, v1, v2, vstride, vorder, new IntPtr(ptr1043)); } 
		}

		public static unsafe GLEnum ObjectPurgeableAPPLE(GLEnum objectType, UInt32 name, GLEnum option)
		{
			return (GLEnum) glObjectPurgeableAPPLE((uint)objectType, name, (uint)option);
		}

		public static unsafe GLEnum ObjectUnpurgeableAPPLE(GLEnum objectType, UInt32 name, GLEnum option)
		{
			return (GLEnum) glObjectUnpurgeableAPPLE((uint)objectType, name, (uint)option);
		}

		public static unsafe void GetObjectParameterivAPPLE(GLEnum objectType, UInt32 name, GLEnum pname, [OutAttribute] Int32[] parameters)
		{
			fixed (Int32* optr1044 = parameters) { glGetObjectParameterivAPPLE((uint)objectType, name, (uint)pname, optr1044); } 
		}

		public static unsafe void BeginVideoCaptureNV(UInt32 video_capture_slot)
		{
			glBeginVideoCaptureNV(video_capture_slot);
		}

		public static unsafe void BindVideoCaptureStreamBufferNV(UInt32 video_capture_slot, UInt32 stream, GLEnum frame_region, IntPtr offset)
		{
			glBindVideoCaptureStreamBufferNV(video_capture_slot, stream, (uint)frame_region, offset);
		}

		public static unsafe void BindVideoCaptureStreamTextureNV(UInt32 video_capture_slot, UInt32 stream, GLEnum frame_region, GLEnum target, UInt32 texture)
		{
			glBindVideoCaptureStreamTextureNV(video_capture_slot, stream, (uint)frame_region, (uint)target, texture);
		}

		public static unsafe void EndVideoCaptureNV(UInt32 video_capture_slot)
		{
			glEndVideoCaptureNV(video_capture_slot);
		}

		public static unsafe void GetVideoCaptureivNV(UInt32 video_capture_slot, GLEnum pname, [OutAttribute] Int32[] parameters)
		{
			fixed (Int32* optr1045 = parameters) { glGetVideoCaptureivNV(video_capture_slot, (uint)pname, optr1045); } 
		}

		public static unsafe void GetVideoCaptureStreamivNV(UInt32 video_capture_slot, UInt32 stream, GLEnum pname, [OutAttribute] Int32[] parameters)
		{
			fixed (Int32* optr1046 = parameters) { glGetVideoCaptureStreamivNV(video_capture_slot, stream, (uint)pname, optr1046); } 
		}

		public static unsafe void GetVideoCaptureStreamfvNV(UInt32 video_capture_slot, UInt32 stream, GLEnum pname, [OutAttribute] float[] parameters)
		{
			fixed (float* optr1047 = parameters) { glGetVideoCaptureStreamfvNV(video_capture_slot, stream, (uint)pname, optr1047); } 
		}

		public static unsafe void GetVideoCaptureStreamdvNV(UInt32 video_capture_slot, UInt32 stream, GLEnum pname, [OutAttribute] double[] parameters)
		{
			fixed (double* optr1048 = parameters) { glGetVideoCaptureStreamdvNV(video_capture_slot, stream, (uint)pname, optr1048); } 
		}

		public static unsafe void VideoCaptureStreamParameterivNV(UInt32 video_capture_slot, UInt32 stream, GLEnum pname, Int32[] parameters)
		{
			fixed (Int32* ptr1049 = &parameters[0]) { glVideoCaptureStreamParameterivNV(video_capture_slot, stream, (uint)pname, new IntPtr(ptr1049)); } 
		}

		public static unsafe void VideoCaptureStreamParameterfvNV(UInt32 video_capture_slot, UInt32 stream, GLEnum pname, float[] parameters)
		{
			fixed (float* ptr1050 = &parameters[0]) { glVideoCaptureStreamParameterfvNV(video_capture_slot, stream, (uint)pname, new IntPtr(ptr1050)); } 
		}

		public static unsafe void VideoCaptureStreamParameterdvNV(UInt32 video_capture_slot, UInt32 stream, GLEnum pname, double[] parameters)
		{
			fixed (double* ptr1051 = &parameters[0]) { glVideoCaptureStreamParameterdvNV(video_capture_slot, stream, (uint)pname, new IntPtr(ptr1051)); } 
		}

		public static unsafe void CopyImageSubDataNV(UInt32 srcName, GLEnum srcTarget, Int32 srcLevel, Int32 srcX, Int32 srcY, Int32 srcZ, UInt32 dstName, GLEnum dstTarget, Int32 dstLevel, Int32 dstX, Int32 dstY, Int32 dstZ, Int32 width, Int32 height, Int32 depth)
		{
			glCopyImageSubDataNV(srcName, (uint)srcTarget, srcLevel, srcX, srcY, srcZ, dstName, (uint)dstTarget, dstLevel, dstX, dstY, dstZ, width, height, depth);
		}

		public static unsafe void UseShaderProgramEXT(GLEnum type, UInt32 program)
		{
			glUseShaderProgramEXT((uint)type, program);
		}

		public static unsafe void ActiveProgramEXT(UInt32 program)
		{
			glActiveProgramEXT(program);
		}

		public static unsafe UInt32 CreateShaderProgramEXT(GLEnum type, byte[] str)
		{
			fixed (byte* ptr1052 = &str[0]) { return glCreateShaderProgramEXT((uint)type, new IntPtr(ptr1052)); } 
		}

		public static unsafe void MakeBufferResidentNV(GLEnum target, GLEnum access)
		{
			glMakeBufferResidentNV((uint)target, (uint)access);
		}

		public static unsafe void MakeBufferNonResidentNV(GLEnum target)
		{
			glMakeBufferNonResidentNV((uint)target);
		}

		public static unsafe bool IsBufferResidentNV(GLEnum target)
		{
			return (glIsBufferResidentNV((uint)target) == 1);
		}

		public static unsafe void MakeNamedBufferResidentNV(UInt32 buffer, GLEnum access)
		{
			glMakeNamedBufferResidentNV(buffer, (uint)access);
		}

		public static unsafe void MakeNamedBufferNonResidentNV(UInt32 buffer)
		{
			glMakeNamedBufferNonResidentNV(buffer);
		}

		public static unsafe bool IsNamedBufferResidentNV(UInt32 buffer)
		{
			return (glIsNamedBufferResidentNV(buffer) == 1);
		}

		public static unsafe void GetBufferParameterui64vNV(GLEnum target, GLEnum pname, [OutAttribute] UInt64[] parameters)
		{
			fixed (UInt64* optr1053 = parameters) { glGetBufferParameterui64vNV((uint)target, (uint)pname, optr1053); } 
		}

		public static unsafe void GetNamedBufferParameterui64vNV(UInt32 buffer, GLEnum pname, [OutAttribute] UInt64[] parameters)
		{
			fixed (UInt64* optr1054 = parameters) { glGetNamedBufferParameterui64vNV(buffer, (uint)pname, optr1054); } 
		}

		public static unsafe void GetIntegerui64vNV(GLEnum val, [OutAttribute] UInt64[] result)
		{
			fixed (UInt64* optr1055 = result) { glGetIntegerui64vNV((uint)val, optr1055); } 
		}

		public static unsafe void Uniformui64NV(Int32 location, UInt64 val)
		{
			glUniformui64NV(location, val);
		}

		public static unsafe void Uniformui64vNV(Int32 location, Int32 count, UInt64[] val)
		{
			fixed (UInt64* ptr1056 = &val[0]) { glUniformui64vNV(location, count, new IntPtr(ptr1056)); } 
		}

		public static unsafe void GetUniformui64vNV(UInt32 program, Int32 location, [OutAttribute] UInt64[] parameters)
		{
			fixed (UInt64* optr1057 = parameters) { glGetUniformui64vNV(program, location, optr1057); } 
		}

		public static unsafe void ProgramUniformui64NV(UInt32 program, Int32 location, UInt64 val)
		{
			glProgramUniformui64NV(program, location, val);
		}

		public static unsafe void ProgramUniformui64vNV(UInt32 program, Int32 location, Int32 count, UInt64[] val)
		{
			fixed (UInt64* ptr1058 = &val[0]) { glProgramUniformui64vNV(program, location, count, new IntPtr(ptr1058)); } 
		}

		public static unsafe void BufferAddressRangeNV(GLEnum pname, UInt32 index, UInt64 address, IntPtr length)
		{
			glBufferAddressRangeNV((uint)pname, index, address, length);
		}

		public static unsafe void VertexFormatNV(Int32 size, GLEnum type, Int32 stride)
		{
			glVertexFormatNV(size, (uint)type, stride);
		}

		public static unsafe void NormalFormatNV(GLEnum type, Int32 stride)
		{
			glNormalFormatNV((uint)type, stride);
		}

		public static unsafe void ColorFormatNV(Int32 size, GLEnum type, Int32 stride)
		{
			glColorFormatNV(size, (uint)type, stride);
		}

		public static unsafe void IndexFormatNV(GLEnum type, Int32 stride)
		{
			glIndexFormatNV((uint)type, stride);
		}

		public static unsafe void TexCoordFormatNV(Int32 size, GLEnum type, Int32 stride)
		{
			glTexCoordFormatNV(size, (uint)type, stride);
		}

		public static unsafe void EdgeFlagFormatNV(Int32 stride)
		{
			glEdgeFlagFormatNV(stride);
		}

		public static unsafe void SecondaryColorFormatNV(Int32 size, GLEnum type, Int32 stride)
		{
			glSecondaryColorFormatNV(size, (uint)type, stride);
		}

		public static unsafe void FogCoordFormatNV(GLEnum type, Int32 stride)
		{
			glFogCoordFormatNV((uint)type, stride);
		}

		public static unsafe void VertexAttribFormatNV(UInt32 index, Int32 size, GLEnum type, bool normalized, Int32 stride)
		{
			glVertexAttribFormatNV(index, size, (uint)type, normalized ? ((byte)1) : ((byte)0), stride);
		}

		public static unsafe void VertexAttribIFormatNV(UInt32 index, Int32 size, GLEnum type, Int32 stride)
		{
			glVertexAttribIFormatNV(index, size, (uint)type, stride);
		}

		public static unsafe void GetIntegerui64i_vNV(GLEnum val, UInt32 index, [OutAttribute] UInt64[] result)
		{
			fixed (UInt64* optr1059 = result) { glGetIntegerui64i_vNV((uint)val, index, optr1059); } 
		}

		public static unsafe void TextureBarrierNV()
		{
			glTextureBarrierNV();
		}

	}
}
